Changeset 7581

Timestamp:

Jan 2, 2009, 8:12:23 PM (12 years ago)

Author:

charles

Message:

(trunk libT) make the tr_bandwidth macros into safer inline funcs. inline utils' one-liners.

Location:

trunk/libtransmission

Files:

• crypto.c (modified) (1 diff)
• utils.c (modified) (4 diffs)
• utils.h (modified) (4 diffs)

trunk/libtransmission/crypto.c

@@ -31 +31 @@
 #include "utils.h"
 
-typedef uint8_t tr_bool;
-
 /**
 ***

trunk/libtransmission/utils.c

@@ -643 +643 @@
 ****/
 
-void*
-tr_memdup( const void * in,
-           int          byteCount )
-{
-    void * out = tr_new( uint8_t, byteCount );
-
-    memcpy( out, in, byteCount );
-    return out;
-}
-
-char*
-tr_strdup( const void * in )
-{
-    return tr_strndup( in, in ? strlen( (const char*)in ) : 0 );
-}
-
 char*
 tr_strndup( const void * in,
@@ -695 +679 @@
     tr_releaseBuffer( buf );
     return ret;
-}
-
-void*
-tr_malloc( size_t size )
-{
-    return size ? malloc( size ) : NULL;
-}
-
-void*
-tr_malloc0( size_t size )
-{
-    return size ? calloc( 1, size ) : NULL;
-}
-
-void
-tr_free( void * p )
-{
-    if( p )
-        free( p );
 }
 
@@ -767 +732 @@
 }
 
-void
+tr_bitfield*
 tr_bitfieldDestruct( tr_bitfield * b )
 {
-    tr_free( b->bits );
-}
-
-tr_bitfield*
-tr_bitfieldNew( size_t bitCount )
-{
-    return tr_bitfieldConstruct( tr_new0( tr_bitfield, 1 ), bitCount );
+    if( b )
+        tr_free( b->bits );
+    return b;
 }
 
@@ -788 +749 @@
     ret->bits = tr_memdup( in->bits, in->byteCount );
     return ret;
-}
-
-void
-tr_bitfieldFree( tr_bitfield * bitfield )
-{
-    if( bitfield )
-    {
-        tr_bitfieldDestruct( bitfield );
-        tr_free( bitfield );
-    }
 }
 

trunk/libtransmission/utils.h

@@ -28 +28 @@
 #include <inttypes.h>
 #include <stdarg.h>
-#include <stddef.h> /* for size_t */
+#include <stddef.h> /* size_t */
 #include <stdio.h> /* FILE* */
+#include <string.h> /* memcpy()* */
+#include <stdlib.h> /* malloc() */
 #include <time.h> /* time_t* */
+
+#include "transmission.h"
 
 #ifdef __cplusplus
@@ -278 +282 @@
 ***/
 
+static inline void* tr_malloc( size_t size )
+{
+    return size ? malloc( size ) : NULL;
+}
+static inline void* tr_malloc0( size_t size )
+{
+    return size ? calloc( 1, size ) : NULL;
+}
+static inline void tr_free( void * p )
+{
+    if( p != NULL )
+        free( p );
+}
+static inline void* tr_memdup( const void * src, int byteCount )
+{
+    return memcpy( tr_malloc( byteCount ), src, byteCount );
+}
+
 #define tr_new( struct_type, n_structs )           \
-    ( (struct_type *) tr_malloc ( ( (size_t) sizeof ( struct_type ) ) * ( (\
-                                                                             size_t) (\
-                                                                             n_structs ) ) ) )
+    ( (struct_type *) tr_malloc ( ( (size_t) sizeof ( struct_type ) ) * ( ( size_t) ( n_structs ) ) ) )
+
 #define tr_new0( struct_type, n_structs )          \
-    ( (struct_type *) tr_malloc0 ( ( (size_t) sizeof ( struct_type ) ) * ( (\
-                                                                              size_t) (\
-                                                                              n_structs ) ) ) )
+    ( (struct_type *) tr_malloc0 ( ( (size_t) sizeof ( struct_type ) ) * ( ( size_t) ( n_structs ) ) ) )
+
 #define tr_renew( struct_type, mem, n_structs )    \
-    ( (struct_type *) realloc ( ( mem ),\
-                               ( (size_t) sizeof ( struct_type ) ) * ( (\
-                                                                          size_t) (\
-                                                                          n_structs ) ) ) )
-
-void*       tr_malloc( size_t ) TR_GNUC_MALLOC;
-
-void*       tr_malloc0( size_t ) TR_GNUC_MALLOC;
-
-void        tr_free( void* );
-
-char*       tr_strdup( const void * str ) TR_GNUC_MALLOC;
-
-char*       tr_strndup( const void * str,
-                        int          len ) TR_GNUC_MALLOC;
-
-void*       tr_memdup( const void * src,
-                       int          byteCount ) TR_GNUC_MALLOC;
+    ( (struct_type *) realloc ( ( mem ), ( (size_t) sizeof ( struct_type ) ) * ( ( size_t) ( n_structs ) ) ) )
+
+char*       tr_strndup( const void * str, int len ) TR_GNUC_MALLOC;
+
+static inline char* tr_strdup( const void * in )
+{
+    return tr_strndup( in, in ? strlen( (const char*)in ) : 0 );
+}
 
 char*       tr_strdup_printf( const char * fmt,
@@ -374 +384 @@
 tr_bitfield* tr_bitfieldConstruct( tr_bitfield*, size_t bitcount );
 
-void         tr_bitfieldDestruct( tr_bitfield* );
-
-tr_bitfield* tr_bitfieldNew( size_t bitcount ) TR_GNUC_MALLOC;
+tr_bitfield* tr_bitfieldDestruct( tr_bitfield* );
+
+static inline tr_bitfield* tr_bitfieldNew( size_t bitcount )
+{
+    return tr_bitfieldConstruct( tr_new0( tr_bitfield, 1 ), bitcount );
+}
+
+static inline void tr_bitfieldFree( tr_bitfield * b )
+{
+    tr_free( tr_bitfieldDestruct( b ) );
+}
 
 tr_bitfield* tr_bitfieldDup( const tr_bitfield* ) TR_GNUC_MALLOC;
-
-void         tr_bitfieldFree( tr_bitfield* );
 
 void         tr_bitfieldClear( tr_bitfield* );
@@ -405 +421 @@
     need to call tr_bitfieldTestFast() first before you
     start looping. */
-#define tr_bitfieldHasFast( bitfield, nth ) \
-    ( ( (bitfield)->bits[( nth ) >> 3u] << ( ( nth ) & 7u ) & 0x80 ) != 0 )
+static inline tr_bool tr_bitfieldHasFast( const tr_bitfield * b, const size_t nth )
+{
+    return ( b->bits[nth>>3u] << ( nth & 7u ) & 0x80 ) != 0;
+}
 
 /** @param high the highest nth bit you're going to access */
-#define tr_bitfieldTestFast( bitfield, high ) \
-    ( ( bitfield ) && ( ( bitfield )->bits )\
-    && ( ( high ) < ( bitfield )->bitCount ) )
-
-#define tr_bitfieldHas( bitfield, nth ) \
-    ( tr_bitfieldTestFast( bitfield, nth )    \
-    && tr_bitfieldHasFast( bitfield, nth ) )
+static inline tr_bool tr_bitfieldTestFast( const tr_bitfield * b, const size_t high )
+{
+    return ( b != NULL )
+        && ( b->bits != NULL )
+        && ( high < b->bitCount );
+}
+
+static inline tr_bool tr_bitfieldHas( const tr_bitfield * b, size_t nth )
+{
+    return tr_bitfieldTestFast( b, nth ) && tr_bitfieldHasFast( b, nth );
+}
 
 double tr_getRatio( double numerator, double denominator );