Ignore:
Timestamp:
Sep 23, 2008, 7:11:04 PM (14 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/bencode.h

    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    TYPE_DICT = 8
    2424};
    25    
     25
    2626typedef struct tr_benc
    2727{
    28     char   type;
     28    char    type;
    2929    union
    3030    {
     
    4848***/
    4949
    50 int tr_bencParse( const void      * buf,
    51                   const void      * bufend,
    52                   tr_benc         * setme_benc,
    53                   const uint8_t  ** setme_end );
    54 
    55 int tr_bencLoad( const void  * buf,
    56                  size_t        buflen,
    57                  tr_benc     * setme_benc,
    58                  char       ** setme_end );
    59 
    60 int    tr_bencLoadFile     ( const char * filename, tr_benc * );
    61 int    tr_bencLoadJSONFile ( const char * filename, tr_benc * );
     50int       tr_bencParse( const void *     buf,
     51                        const void *     bufend,
     52                        tr_benc *        setme_benc,
     53                        const uint8_t ** setme_end );
     54
     55int       tr_bencLoad( const void * buf,
     56                       size_t       buflen,
     57                       tr_benc *    setme_benc,
     58                       char **      setme_end );
     59
     60int       tr_bencLoadFile( const char * filename,
     61                                        tr_benc * );
     62
     63int       tr_bencLoadJSONFile( const char * filename,
     64                                            tr_benc * );
    6265
    6366#if 0
    64 void  tr_bencPrint( const tr_benc * );
     67void      tr_bencPrint( const tr_benc * );
     68
    6569#endif
    6670
    67 void  tr_bencFree( tr_benc * );
    68 
    69 char*  tr_bencSave         ( const tr_benc * val, int * len );
    70 char*  tr_bencSaveAsJSON   ( const tr_benc * top, int * len );
    71 int    tr_bencSaveFile     ( const char * filename, const tr_benc * );
    72 int    tr_bencSaveJSONFile ( const char * filename, const tr_benc * );
    73 
    74 void  tr_bencInitStr( tr_benc *, const void * str, int str_len );
    75 void  tr_bencInitRaw( tr_benc *, const void * raw, size_t raw_len );
    76 void  tr_bencInitInt( tr_benc *, int64_t num );
    77 int   tr_bencInitDict( tr_benc *, size_t reserveCount );
    78 int   tr_bencInitList( tr_benc *, size_t reserveCount );
    79 
    80 /***
    81 ****
    82 ***/
    83 
    84 int tr_bencListReserve( tr_benc *, size_t reserveCount );
     71void      tr_bencFree( tr_benc * );
     72
     73char*     tr_bencSave( const tr_benc * val,
     74                       int *           len );
     75
     76char*     tr_bencSaveAsJSON( const tr_benc * top,
     77                             int *           len );
     78
     79int       tr_bencSaveFile( const char * filename,
     80                           const        tr_benc * );
     81
     82int       tr_bencSaveJSONFile( const char * filename,
     83                               const        tr_benc * );
     84
     85void      tr_bencInitStr(                       tr_benc *,
     86                                   const void * str,
     87                                   int          str_len );
     88
     89void      tr_bencInitRaw(                       tr_benc *,
     90                                   const void * raw,
     91                                   size_t       raw_len );
     92
     93void      tr_bencInitInt(             tr_benc *,
     94                              int64_t num );
     95
     96int       tr_bencInitDict(           tr_benc *,
     97                              size_t reserveCount );
     98
     99int       tr_bencInitList(           tr_benc *,
     100                              size_t reserveCount );
     101
     102/***
     103****
     104***/
     105
     106int       tr_bencListReserve(         tr_benc *,
     107                               size_t reserveCount );
     108
    85109tr_benc * tr_bencListAdd( tr_benc * );
    86 tr_benc * tr_bencListAddInt( tr_benc *, int64_t val );
    87 tr_benc * tr_bencListAddStr( tr_benc *, const char * val );
    88 tr_benc * tr_bencListAddList( tr_benc *, size_t reserveCount );
    89 tr_benc * tr_bencListAddDict( tr_benc *, size_t reserveCount );
    90 
    91 size_t tr_bencListSize( const tr_benc * list );
    92 tr_benc * tr_bencListChild( tr_benc * list, size_t n );
    93 
    94 /***
    95 ****
    96 ***/
    97 
    98 int tr_bencDictReserve( tr_benc *, size_t reserveCount );
    99 int tr_bencDictRemove( tr_benc *, const char * key );
    100 tr_benc * tr_bencDictAdd( tr_benc *, const char * key );
    101 tr_benc * tr_bencDictAddDouble( tr_benc *, const char * key, double d );
    102 tr_benc * tr_bencDictAddInt( tr_benc *, const char * key, int64_t val );
    103 tr_benc * tr_bencDictAddStr( tr_benc *, const char * key, const char * val );
    104 tr_benc * tr_bencDictAddList( tr_benc *, const char * key, size_t reserve );
    105 tr_benc * tr_bencDictAddDict( tr_benc *, const char * key, size_t reserve );
    106 tr_benc * tr_bencDictAddRaw( tr_benc *, const char * key,
    107                              const void *, size_t len );
    108 
    109 tr_benc* tr_bencDictFind( tr_benc *, const char * key );
    110 int tr_bencDictFindList( tr_benc *, const char * key, tr_benc ** setme );
    111 int tr_bencDictFindDict( tr_benc *, const char * key, tr_benc ** setme );
    112 int tr_bencDictFindInt( tr_benc *, const char * key, int64_t * setme );
    113 int tr_bencDictFindDouble( tr_benc *, const char * key, double * setme );
    114 int tr_bencDictFindStr( tr_benc *, const char * key, const char ** setme );
    115 int tr_bencDictFindRaw( tr_benc *, const char * key,
    116                           const uint8_t ** setme_raw, size_t * setme_len );
    117 
    118 /***
    119 ****
    120 ***/
    121 
    122 int tr_bencGetInt( const tr_benc * val, int64_t * setme );
    123 int tr_bencGetStr( const tr_benc * val, const char ** setme );
    124 int tr_bencIsType( const tr_benc *, int type );
     110
     111tr_benc * tr_bencListAddInt(                 tr_benc *,
     112                                     int64_t val );
     113
     114tr_benc * tr_bencListAddStr(                           tr_benc *,
     115                                          const char * val );
     116
     117tr_benc * tr_bencListAddList(               tr_benc *,
     118                                     size_t reserveCount );
     119
     120tr_benc * tr_bencListAddDict(               tr_benc *,
     121                                     size_t reserveCount );
     122
     123size_t    tr_bencListSize( const tr_benc * list );
     124
     125tr_benc * tr_bencListChild( tr_benc * list,
     126                            size_t    n );
     127
     128/***
     129****
     130***/
     131
     132int       tr_bencDictReserve(         tr_benc *,
     133                               size_t reserveCount );
     134
     135int       tr_bencDictRemove(                     tr_benc *,
     136                                    const char * key );
     137
     138tr_benc * tr_bencDictAdd(                           tr_benc *,
     139                                       const char * key );
     140
     141tr_benc * tr_bencDictAddDouble(                           tr_benc *,
     142                                             const char * key,
     143                                             double       d );
     144
     145tr_benc * tr_bencDictAddInt(                           tr_benc *,
     146                                          const char * key,
     147                                          int64_t      val );
     148
     149tr_benc * tr_bencDictAddStr(                           tr_benc *,
     150                                          const char * key,
     151                                          const char * val );
     152
     153tr_benc * tr_bencDictAddList(                           tr_benc *,
     154                                           const char * key,
     155                                           size_t       reserve );
     156
     157tr_benc * tr_bencDictAddDict(                           tr_benc *,
     158                                           const char * key,
     159                                           size_t       reserve );
     160
     161tr_benc * tr_bencDictAddRaw(                           tr_benc *,
     162                                          const char * key,
     163                                          const        void *,
     164                                          size_t       len );
     165
     166tr_benc*  tr_bencDictFind(                          tr_benc *,
     167                                       const char * key );
     168
     169int       tr_bencDictFindList(                     tr_benc *,
     170                                      const char * key,
     171                                      tr_benc **   setme );
     172
     173int       tr_bencDictFindDict(                     tr_benc *,
     174                                      const char * key,
     175                                      tr_benc **   setme );
     176
     177int       tr_bencDictFindInt(                     tr_benc *,
     178                                     const char * key,
     179                                     int64_t *    setme );
     180
     181int       tr_bencDictFindDouble(                     tr_benc *,
     182                                        const char * key,
     183                                        double *     setme );
     184
     185int       tr_bencDictFindStr(                       tr_benc *,
     186                                      const char *  key,
     187                                      const char ** setme );
     188
     189int       tr_bencDictFindRaw(                             tr_benc *,
     190                                         const char *     key,
     191                                         const uint8_t ** setme_raw,
     192                                         size_t *         setme_len );
     193
     194/***
     195****
     196***/
     197
     198int       tr_bencGetInt( const tr_benc * val,
     199                         int64_t *       setme );
     200
     201int       tr_bencGetStr( const tr_benc * val,
     202                         const char **   setme );
     203
     204int       tr_bencIsType( const tr_benc *,
     205                         int   type );
     206
    125207#define tr_bencIsInt( b )    tr_bencIsType( ( b ), TYPE_INT )
    126208#define tr_bencIsDict( b )   tr_bencIsType( ( b ), TYPE_DICT )
     
    133215**/
    134216
    135 int  tr_bencParseInt( const uint8_t  * buf,
    136                       const uint8_t  * bufend,
    137                       const uint8_t ** setme_end,
    138                       int64_t        * setme_val );
    139 
    140 int  tr_bencParseStr( const uint8_t  * buf,
    141                       const uint8_t  * bufend,
    142                       const uint8_t ** setme_end,
    143                       const uint8_t ** setme_str,
    144                       size_t         * setme_strlen );
     217int tr_bencParseInt( const uint8_t * buf,
     218                     const uint8_t * bufend,
     219                     const uint8_t ** setme_end,
     220                     int64_t *        setme_val );
     221
     222int tr_bencParseStr( const uint8_t * buf,
     223                     const uint8_t * bufend,
     224                     const uint8_t ** setme_end,
     225                     const uint8_t ** setme_str,
     226                     size_t *        setme_strlen );
    145227
    146228#endif
Note: See TracChangeset for help on using the changeset viewer.