Ignore:
Timestamp:
Mar 22, 2011, 3:19:54 PM (11 years ago)
Author:
jordan
Message:

(trunk) #4138 "use stdbool.h instead of tr_bool" -- done.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/torrent.c

    r12178 r12204  
    151151}
    152152
    153 tr_bool
     153bool
    154154tr_torrentIsPieceTransferAllowed( const tr_torrent  * tor,
    155155                                  tr_direction        direction )
    156156{
    157157    int limit;
    158     tr_bool allowed = TRUE;
     158    bool allowed = true;
    159159
    160160    if( tr_torrentUsesSpeedLimit( tor, direction ) )
    161161        if( tr_torrentGetSpeedLimit_Bps( tor, direction ) <= 0 )
    162             allowed = FALSE;
     162            allowed = false;
    163163
    164164    if( tr_torrentUsesSessionLimits( tor ) )
    165165        if( tr_sessionGetActiveSpeedLimit_Bps( tor->session, direction, &limit ) )
    166166            if( limit <= 0 )
    167                 allowed = FALSE;
     167                allowed = false;
    168168
    169169    return allowed;
     
    205205
    206206void
    207 tr_torrentUseSpeedLimit( tr_torrent * tor, tr_direction dir, tr_bool do_use )
     207tr_torrentUseSpeedLimit( tr_torrent * tor, tr_direction dir, bool do_use )
    208208{
    209209    assert( tr_isTorrent( tor ) );
     
    214214}
    215215
    216 tr_bool
     216bool
    217217tr_torrentUsesSpeedLimit( const tr_torrent * tor, tr_direction dir )
    218218{
     
    224224
    225225void
    226 tr_torrentUseSessionLimits( tr_torrent * tor, tr_bool doUse )
    227 {
    228     tr_bool changed;
     226tr_torrentUseSessionLimits( tr_torrent * tor, bool doUse )
     227{
     228    bool changed;
    229229
    230230    assert( tr_isTorrent( tor ) );
     
    237237}
    238238
    239 tr_bool
     239bool
    240240tr_torrentUsesSessionLimits( const tr_torrent * tor )
    241241{
     
    292292}
    293293
    294 tr_bool
     294bool
    295295tr_torrentGetSeedRatio( const tr_torrent * tor, double * ratio )
    296296{
    297     tr_bool isLimited;
     297    bool isLimited;
    298298
    299299    switch( tr_torrentGetRatioMode( tor ) )
    300300    {
    301301        case TR_RATIOLIMIT_SINGLE:
    302             isLimited = TRUE;
     302            isLimited = true;
    303303            if( ratio )
    304304                *ratio = tr_torrentGetRatioLimit( tor );
     
    312312
    313313        default: /* TR_RATIOLIMIT_UNLIMITED */
    314             isLimited = FALSE;
     314            isLimited = false;
    315315            break;
    316316    }
     
    321321/* returns true if the seed ratio applies --
    322322 * it applies if the torrent's a seed AND it has a seed ratio set */
    323 static tr_bool
     323static bool
    324324tr_torrentGetSeedRatioBytes( tr_torrent  * tor,
    325325                             uint64_t    * setmeLeft,
     
    327327{
    328328    double seedRatio;
    329     tr_bool seedRatioApplies = FALSE;
     329    bool seedRatioApplies = false;
    330330
    331331    if( tr_torrentGetSeedRatio( tor, &seedRatio ) )
     
    343343}
    344344
    345 static tr_bool
     345static bool
    346346tr_torrentIsSeedRatioDone( tr_torrent * tor )
    347347{
     
    397397}
    398398
    399 tr_bool
     399bool
    400400tr_torrentGetSeedIdle( const tr_torrent * tor, uint16_t * idleMinutes )
    401401{
    402     tr_bool isLimited;
     402    bool isLimited;
    403403
    404404    switch( tr_torrentGetIdleMode( tor ) )
    405405    {
    406406        case TR_IDLELIMIT_SINGLE:
    407             isLimited = TRUE;
     407            isLimited = true;
    408408            if( idleMinutes )
    409409                *idleMinutes = tr_torrentGetIdleLimit( tor );
     
    417417
    418418        default: /* TR_IDLELIMIT_UNLIMITED */
    419             isLimited = FALSE;
     419            isLimited = false;
    420420            break;
    421421    }
     
    424424}
    425425
    426 static tr_bool
     426static bool
    427427tr_torrentIsSeedIdleLimitDone( tr_torrent * tor )
    428428{
     
    449449        tr_torinf( tor, "Seed ratio reached; pausing torrent" );
    450450
    451         tor->isStopping = TRUE;
     451        tor->isStopping = true;
    452452
    453453        /* maybe notify the client */
     
    460460        tr_torinf( tor, "Seeding idle limit reached; pausing torrent" );
    461461
    462         tor->isStopping = TRUE;
    463         tor->finishedSeedingByIdle = TRUE;
     462        tor->isStopping = true;
     463        tor->finishedSeedingByIdle = true;
    464464
    465465        /* maybe notify the client */
     
    489489
    490490    if( tor->isRunning )
    491         tor->isStopping = TRUE;
     491        tor->isStopping = true;
    492492}
    493493
     
    509509            size_t i;
    510510            const int8_t seedProbability = event->seedProbability;
    511             const tr_bool allAreSeeds = seedProbability == 100;
     511            const bool allAreSeeds = seedProbability == 100;
    512512
    513513             if( allAreSeeds )
     
    760760}
    761761
    762 static tr_bool
     762static bool
    763763hasAnyLocalData( const tr_torrent * tor )
    764764{
    765765    tr_file_index_t i;
    766     tr_bool has_local_data = FALSE;
     766    bool has_local_data = false;
    767767    const tr_file_index_t n = tor->info.fileCount;
    768768
     
    773773
    774774        if( filename && !stat( filename, &sb ) )
    775             has_local_data = TRUE;
     775            has_local_data = true;
    776776
    777777        tr_free( filename );
     
    781781}
    782782
    783 static tr_bool
     783static bool
    784784setLocalErrorIfFilesDisappeared( tr_torrent * tor )
    785785{
    786     const tr_bool disappeared = ( tr_cpHaveTotal( &tor->completion ) > 0 ) && !hasAnyLocalData( tor );
     786    const bool disappeared = ( tr_cpHaveTotal( &tor->completion ) > 0 ) && !hasAnyLocalData( tor );
    787787
    788788    if( disappeared )
     
    801801    uint64_t loaded;
    802802    const char * dir;
    803     tr_bool isNewTorrent;
     803    bool isNewTorrent;
    804804    struct stat st;
    805805    static int nextUniqueId = 1;
     
    835835    tor->error = TR_STAT_OK;
    836836
    837     tor->finishedSeedingByIdle = FALSE;
     837    tor->finishedSeedingByIdle = false;
    838838
    839839    tr_peerMgrAddTorrent( session->peerMgr, tor );
     
    860860    if( !( loaded & TR_FR_SPEEDLIMIT ) )
    861861    {
    862         tr_torrentUseSpeedLimit( tor, TR_UP, FALSE );
     862        tr_torrentUseSpeedLimit( tor, TR_UP, false );
    863863        tr_torrentSetSpeedLimit_Bps( tor, TR_UP, tr_sessionGetSpeedLimit_Bps( tor->session, TR_UP ) );
    864         tr_torrentUseSpeedLimit( tor, TR_DOWN, FALSE );
     864        tr_torrentUseSpeedLimit( tor, TR_DOWN, false );
    865865        tr_torrentSetSpeedLimit_Bps( tor, TR_DOWN, tr_sessionGetSpeedLimit_Bps( tor->session, TR_DOWN ) );
    866         tr_torrentUseSessionLimits( tor, TRUE );
     866        tr_torrentUseSessionLimits( tor, true );
    867867    }
    868868
     
    926926static tr_parse_result
    927927torrentParseImpl( const tr_ctor * ctor, tr_info * setmeInfo,
    928                   tr_bool * setmeHasInfo, int * dictLength )
     928                  bool * setmeHasInfo, int * dictLength )
    929929{
    930930    int             doFree;
    931     tr_bool         didParse;
    932     tr_bool         hasInfo = FALSE;
     931    bool            didParse;
     932    bool            hasInfo = false;
    933933    tr_info         tmp;
    934934    const tr_benc * metainfo;
     
    975975{
    976976    int len;
    977     tr_bool hasInfo;
     977    bool hasInfo;
    978978    tr_info tmpInfo;
    979979    tr_parse_result r;
     
    10681068}
    10691069
    1070 tr_bool
     1070bool
    10711071tr_torrentCanManualUpdate( const tr_torrent * tor )
    10721072{
     
    11441144    uint64_t                seedRatioBytesLeft;
    11451145    uint64_t                seedRatioBytesGoal;
    1146     tr_bool                 seedRatioApplies;
     1146    bool                    seedRatioApplies;
    11471147    uint16_t                seedIdleMinutes;
    11481148
     
    13511351    tr_file_stat *        files = tr_new0( tr_file_stat, n );
    13521352    tr_file_stat *        walk = files;
    1353     const tr_bool         isSeed = tor->completeness == TR_SEED;
     1353    const bool            isSeed = tor->completeness == TR_SEED;
    13541354
    13551355    assert( tr_isTorrent( tor ) );
     
    14781478tr_torrentSetHasPiece( tr_torrent *     tor,
    14791479                       tr_piece_index_t pieceIndex,
    1480                        tr_bool          has )
     1480                       bool             has )
    14811481{
    14821482    assert( tr_isTorrent( tor ) );
     
    15501550
    15511551    now = tr_time( );
    1552     tor->isRunning = TRUE;
     1552    tor->isRunning = true;
    15531553    tor->completeness = tr_cpGetStatus( &tor->completion );
    15541554    tor->startDate = tor->anyDate = now;
    15551555    tr_torrentClearError( tor );
    1556     tor->finishedSeedingByIdle = FALSE;
     1556    tor->finishedSeedingByIdle = false;
    15571557
    15581558    tr_torrentResetTransferStats( tor );
     
    16021602     * we'll know what completeness to use/announce */
    16031603    if( tor->verifyState != TR_VERIFY_NONE ) {
    1604         tor->startAfterVerify = TRUE;
     1604        tor->startAfterVerify = true;
    16051605        return;
    16061606    }
     
    16441644
    16451645    if( tor->startAfterVerify ) {
    1646         tor->startAfterVerify = FALSE;
     1646        tor->startAfterVerify = false;
    16471647        torrentStart( tor );
    16481648    }
     
    16701670    if( tor->startAfterVerify || tor->isRunning ) {
    16711671        /* don't clobber isStopping */
    1672         const tr_bool startAfter = tor->isStopping ? FALSE : TRUE;
     1672        const bool startAfter = tor->isStopping ? false : true;
    16731673        tr_torrentStop( tor );
    16741674        tor->startAfterVerify = startAfter;
     
    16761676
    16771677    if( setLocalErrorIfFilesDisappeared( tor ) )
    1678         tor->startAfterVerify = FALSE;
     1678        tor->startAfterVerify = false;
    16791679    else
    16801680        tr_verifyAdd( tor, torrentRecheckDoneCB );
     
    16971697    if( tor->isDirty )
    16981698    {
    1699         tor->isDirty = FALSE;
     1699        tor->isDirty = false;
    17001700        tr_torrentSaveResume( tor );
    17011701    }
     
    17881788{
    17891789    tr_torrent   * tor;
    1790     tr_bool        deleteFlag;
     1790    bool           deleteFlag;
    17911791    tr_fileFunc  * deleteFunc;
    17921792};
     
    18091809void
    18101810tr_torrentRemove( tr_torrent   * tor,
    1811                   tr_bool        deleteFlag,
     1811                  bool           deleteFlag,
    18121812                  tr_fileFunc    deleteFunc )
    18131813{
     
    18521852fireCompletenessChange( tr_torrent       * tor,
    18531853                        tr_completeness    status,
    1854                         tr_bool            wasRunning )
     1854                        bool               wasRunning )
    18551855{
    18561856    assert( ( status == TR_LEECH )
     
    19771977    {
    19781978        const int recentChange = tor->downloadedCur != 0;
    1979         const tr_bool wasLeeching = !tr_torrentIsSeed( tor );
    1980         const tr_bool wasRunning = tor->isRunning;
     1979        const bool wasLeeching = !tr_torrentIsSeed( tor );
     1980        const bool wasRunning = tor->isRunning;
    19811981
    19821982        if( recentChange )
     
    20082008
    20092009            if( tor->currentDir == tor->incompleteDir )
    2010                 tr_torrentSetLocation( tor, tor->downloadDir, TRUE, NULL, NULL );
     2010                tr_torrentSetLocation( tor, tor->downloadDir, true, NULL, NULL );
    20112011
    20122012            if( tr_sessionIsTorrentDoneScriptEnabled( tor->session ) )
     
    21672167                       const tr_file_index_t  * files,
    21682168                       tr_file_index_t          fileCount,
    2169                        tr_bool                  doDownload )
     2169                       bool                     doDownload )
    21702170{
    21712171    tr_file_index_t i;
     
    21882188                      const tr_file_index_t  * files,
    21892189                      tr_file_index_t          fileCount,
    2190                       tr_bool                  doDownload )
     2190                      bool                     doDownload )
    21912191{
    21922192    assert( tr_isTorrent( tor ) );
     
    22862286}
    22872287
    2288 tr_bool
     2288bool
    22892289tr_torrentReqIsValid( const tr_torrent * tor,
    22902290                      tr_piece_index_t   index,
     
    23882388}
    23892389
    2390 tr_bool
     2390bool
    23912391tr_torrentCheckPiece( tr_torrent * tor, tr_piece_index_t pieceIndex )
    23922392{
    2393     const tr_bool pass = tr_ioTestPiece( tor, pieceIndex );
     2393    const bool pass = tr_ioTestPiece( tor, pieceIndex );
    23942394
    23952395    tr_deeplog_tor( tor, "[LAZY] tr_torrentCheckPiece tested piece %zu, pass==%d", (size_t)pieceIndex, (int)pass );
     
    24222422}
    24232423
    2424 tr_bool
     2424bool
    24252425tr_torrentPieceNeedsCheck( const tr_torrent * tor, tr_piece_index_t p )
    24262426{
     
    24312431    /* if we've never checked this piece, then it needs to be checked */
    24322432    if( !inf->pieces[p].timeChecked )
    2433         return TRUE;
     2433        return true;
    24342434
    24352435    /* If we think we've completed one of the files in this piece,
     
    24402440        if( tr_cpFileIsComplete( &tor->completion, f ) )
    24412441            if( tr_torrentGetFileMTime( tor, f ) > inf->pieces[p].timeChecked )
    2442                 return TRUE;
    2443 
    2444     return FALSE;
     2442                return true;
     2443
     2444    return false;
    24452445}
    24462446
     
    24632463}
    24642464
    2465 tr_bool
     2465bool
    24662466tr_torrentSetAnnounceList( tr_torrent             * tor,
    24672467                           const tr_tracker_info  * trackers_in,
     
    24702470    int i;
    24712471    tr_benc metainfo;
    2472     tr_bool ok = TRUE;
     2472    bool ok = true;
    24732473    tr_tracker_info * trackers;
    24742474
     
    24842484    for( i=0; ok && i<trackerCount; ++i )
    24852485        if( !tr_urlIsValidTracker( trackers[i].announce ) )
    2486             ok = FALSE;
     2486            ok = false;
    24872487
    24882488    /* save to the .torrent file */
    24892489    if( ok && !tr_bencLoadFile( &metainfo, TR_FMT_BENC, tor->info.torrent ) )
    24902490    {
    2491         tr_bool hasInfo;
     2491        bool hasInfo;
    24922492        tr_info tmpInfo;
    24932493
     
    25452545            || ( tor->error == TR_STAT_TRACKER_ERROR ) )
    25462546        {
    2547             tr_bool clear = TRUE;
     2547            bool clear = true;
    25482548
    25492549            for( i=0; clear && i<trackerCount; ++i )
    25502550                if( !strcmp( trackers[i].announce, tor->errorTracker ) )
    2551                     clear = FALSE;
     2551                    clear = false;
    25522552
    25532553            if( clear )
     
    27062706        {
    27072707            const char * sub = buf + strlen( tor->currentDir ) + strlen( TR_PATH_DELIMITER_STR );
    2708             const tr_bool isTorrentFile = tr_ptrArrayFindSorted( torrentFiles, sub, vstrcmp ) != NULL;
     2708            const bool isTorrentFile = tr_ptrArrayFindSorted( torrentFiles, sub, vstrcmp ) != NULL;
    27092709            if( !isTorrentFile )
    27102710                addDirtyFile( root, buf, dirtyFolders );
     
    28272827struct LocationData
    28282828{
    2829     tr_bool move_from_old_location;
     2829    bool move_from_old_location;
    28302830    volatile int * setme_state;
    28312831    volatile double * setme_progress;
     
    28372837setLocation( void * vdata )
    28382838{
    2839     tr_bool err = FALSE;
     2839    bool err = false;
    28402840    struct LocationData * data = vdata;
    28412841    tr_torrent * tor = data->tor;
    2842     const tr_bool do_move = data->move_from_old_location;
     2842    const bool do_move = data->move_from_old_location;
    28432843    const char * location = data->location;
    28442844    double bytesHandled = 0;
     
    28752875                if( do_move && !tr_is_same_file( oldpath, newpath ) )
    28762876                {
    2877                     tr_bool renamed = FALSE;
     2877                    bool renamed = false;
    28782878                    errno = 0;
    28792879                    tr_torinf( tor, "moving \"%s\" to \"%s\"", oldpath, newpath );
    28802880                    if( tr_moveFile( oldpath, newpath, &renamed ) )
    28812881                    {
    2882                         err = TRUE;
     2882                        err = true;
    28832883                        tr_torerr( tor, "error moving \"%s\" to \"%s\": %s",
    28842884                                        oldpath, newpath, tr_strerror( errno ) );
     
    29272927tr_torrentSetLocation( tr_torrent       * tor,
    29282928                       const char       * location,
    2929                        tr_bool             move_from_old_location,
     2929                       bool               move_from_old_location,
    29302930                       volatile double  * setme_progress,
    29312931                       volatile int     * setme_state )
     
    29982998***/
    29992999
    3000 static tr_bool
     3000static bool
    30013001fileExists( const char * filename )
    30023002{
    30033003    struct stat sb;
    3004     const tr_bool ok = !stat( filename, &sb );
     3004    const bool ok = !stat( filename, &sb );
    30053005    return ok;
    30063006}
    30073007
    3008 tr_bool
     3008bool
    30093009tr_torrentFindFile2( const tr_torrent * tor, tr_file_index_t fileNum,
    30103010                     const char ** base, char ** subpath )
Note: See TracChangeset for help on using the changeset viewer.