|
@@ -53,21 +53,21 @@ void smartlist_subtract(smartlist_t *sl1, const smartlist_t *sl2);
|
|
|
#ifdef DEBUG_SMARTLIST
|
|
|
/** Return the number of items in sl.
|
|
|
*/
|
|
|
-static INLINE int smartlist_len(const smartlist_t *sl);
|
|
|
-static INLINE int smartlist_len(const smartlist_t *sl) {
|
|
|
+static inline int smartlist_len(const smartlist_t *sl);
|
|
|
+static inline int smartlist_len(const smartlist_t *sl) {
|
|
|
tor_assert(sl);
|
|
|
return (sl)->num_used;
|
|
|
}
|
|
|
/** Return the <b>idx</b>th element of sl.
|
|
|
*/
|
|
|
-static INLINE void *smartlist_get(const smartlist_t *sl, int idx);
|
|
|
-static INLINE void *smartlist_get(const smartlist_t *sl, int idx) {
|
|
|
+static inline void *smartlist_get(const smartlist_t *sl, int idx);
|
|
|
+static inline void *smartlist_get(const smartlist_t *sl, int idx) {
|
|
|
tor_assert(sl);
|
|
|
tor_assert(idx>=0);
|
|
|
tor_assert(sl->num_used > idx);
|
|
|
return sl->list[idx];
|
|
|
}
|
|
|
-static INLINE void smartlist_set(smartlist_t *sl, int idx, void *val) {
|
|
|
+static inline void smartlist_set(smartlist_t *sl, int idx, void *val) {
|
|
|
tor_assert(sl);
|
|
|
tor_assert(idx>=0);
|
|
|
tor_assert(sl->num_used > idx);
|
|
@@ -81,7 +81,7 @@ static INLINE void smartlist_set(smartlist_t *sl, int idx, void *val) {
|
|
|
|
|
|
/** Exchange the elements at indices <b>idx1</b> and <b>idx2</b> of the
|
|
|
* smartlist <b>sl</b>. */
|
|
|
-static INLINE void smartlist_swap(smartlist_t *sl, int idx1, int idx2)
|
|
|
+static inline void smartlist_swap(smartlist_t *sl, int idx1, int idx2)
|
|
|
{
|
|
|
if (idx1 != idx2) {
|
|
|
void *elt = smartlist_get(sl, idx1);
|
|
@@ -500,64 +500,64 @@ void* strmap_remove_lc(strmap_t *map, const char *key);
|
|
|
#define DECLARE_TYPED_DIGESTMAP_FNS(prefix, maptype, valtype) \
|
|
|
typedef struct maptype maptype; \
|
|
|
typedef struct prefix##iter_t *prefix##iter_t; \
|
|
|
- ATTR_UNUSED static INLINE maptype* \
|
|
|
+ ATTR_UNUSED static inline maptype* \
|
|
|
prefix##new(void) \
|
|
|
{ \
|
|
|
return (maptype*)digestmap_new(); \
|
|
|
} \
|
|
|
- ATTR_UNUSED static INLINE digestmap_t* \
|
|
|
+ ATTR_UNUSED static inline digestmap_t* \
|
|
|
prefix##to_digestmap(maptype *map) \
|
|
|
{ \
|
|
|
return (digestmap_t*)map; \
|
|
|
} \
|
|
|
- ATTR_UNUSED static INLINE valtype* \
|
|
|
+ ATTR_UNUSED static inline valtype* \
|
|
|
prefix##get(maptype *map, const char *key) \
|
|
|
{ \
|
|
|
return (valtype*)digestmap_get((digestmap_t*)map, key); \
|
|
|
} \
|
|
|
- ATTR_UNUSED static INLINE valtype* \
|
|
|
+ ATTR_UNUSED static inline valtype* \
|
|
|
prefix##set(maptype *map, const char *key, valtype *val) \
|
|
|
{ \
|
|
|
return (valtype*)digestmap_set((digestmap_t*)map, key, val); \
|
|
|
} \
|
|
|
- ATTR_UNUSED static INLINE valtype* \
|
|
|
+ ATTR_UNUSED static inline valtype* \
|
|
|
prefix##remove(maptype *map, const char *key) \
|
|
|
{ \
|
|
|
return (valtype*)digestmap_remove((digestmap_t*)map, key); \
|
|
|
} \
|
|
|
- ATTR_UNUSED static INLINE void \
|
|
|
+ ATTR_UNUSED static inline void \
|
|
|
prefix##free(maptype *map, void (*free_val)(void*)) \
|
|
|
{ \
|
|
|
digestmap_free((digestmap_t*)map, free_val); \
|
|
|
} \
|
|
|
- ATTR_UNUSED static INLINE int \
|
|
|
+ ATTR_UNUSED static inline int \
|
|
|
prefix##isempty(maptype *map) \
|
|
|
{ \
|
|
|
return digestmap_isempty((digestmap_t*)map); \
|
|
|
} \
|
|
|
- ATTR_UNUSED static INLINE int \
|
|
|
+ ATTR_UNUSED static inline int \
|
|
|
prefix##size(maptype *map) \
|
|
|
{ \
|
|
|
return digestmap_size((digestmap_t*)map); \
|
|
|
} \
|
|
|
- ATTR_UNUSED static INLINE \
|
|
|
+ ATTR_UNUSED static inline \
|
|
|
prefix##iter_t *prefix##iter_init(maptype *map) \
|
|
|
{ \
|
|
|
return (prefix##iter_t*) digestmap_iter_init((digestmap_t*)map); \
|
|
|
} \
|
|
|
- ATTR_UNUSED static INLINE \
|
|
|
+ ATTR_UNUSED static inline \
|
|
|
prefix##iter_t *prefix##iter_next(maptype *map, prefix##iter_t *iter) \
|
|
|
{ \
|
|
|
return (prefix##iter_t*) digestmap_iter_next( \
|
|
|
(digestmap_t*)map, (digestmap_iter_t*)iter); \
|
|
|
} \
|
|
|
- ATTR_UNUSED static INLINE prefix##iter_t* \
|
|
|
+ ATTR_UNUSED static inline prefix##iter_t* \
|
|
|
prefix##iter_next_rmv(maptype *map, prefix##iter_t *iter) \
|
|
|
{ \
|
|
|
return (prefix##iter_t*) digestmap_iter_next_rmv( \
|
|
|
(digestmap_t*)map, (digestmap_iter_t*)iter); \
|
|
|
} \
|
|
|
- ATTR_UNUSED static INLINE void \
|
|
|
+ ATTR_UNUSED static inline void \
|
|
|
prefix##iter_get(prefix##iter_t *iter, \
|
|
|
const char **keyp, \
|
|
|
valtype **valp) \
|
|
@@ -566,7 +566,7 @@ void* strmap_remove_lc(strmap_t *map, const char *key);
|
|
|
digestmap_iter_get((digestmap_iter_t*) iter, keyp, &v); \
|
|
|
*valp = v; \
|
|
|
} \
|
|
|
- ATTR_UNUSED static INLINE int \
|
|
|
+ ATTR_UNUSED static inline int \
|
|
|
prefix##iter_done(prefix##iter_t *iter) \
|
|
|
{ \
|
|
|
return digestmap_iter_done((digestmap_iter_t*)iter); \
|
|
@@ -584,7 +584,7 @@ void* strmap_remove_lc(strmap_t *map, const char *key);
|
|
|
/** A random-access array of one-bit-wide elements. */
|
|
|
typedef unsigned int bitarray_t;
|
|
|
/** Create a new bit array that can hold <b>n_bits</b> bits. */
|
|
|
-static INLINE bitarray_t *
|
|
|
+static inline bitarray_t *
|
|
|
bitarray_init_zero(unsigned int n_bits)
|
|
|
{
|
|
|
/* round up to the next int. */
|
|
@@ -594,7 +594,7 @@ bitarray_init_zero(unsigned int n_bits)
|
|
|
/** Expand <b>ba</b> from holding <b>n_bits_old</b> to <b>n_bits_new</b>,
|
|
|
* clearing all new bits. Returns a possibly changed pointer to the
|
|
|
* bitarray. */
|
|
|
-static INLINE bitarray_t *
|
|
|
+static inline bitarray_t *
|
|
|
bitarray_expand(bitarray_t *ba,
|
|
|
unsigned int n_bits_old, unsigned int n_bits_new)
|
|
|
{
|
|
@@ -611,26 +611,26 @@ bitarray_expand(bitarray_t *ba,
|
|
|
return (bitarray_t*) ptr;
|
|
|
}
|
|
|
/** Free the bit array <b>ba</b>. */
|
|
|
-static INLINE void
|
|
|
+static inline void
|
|
|
bitarray_free(bitarray_t *ba)
|
|
|
{
|
|
|
tor_free(ba);
|
|
|
}
|
|
|
/** Set the <b>bit</b>th bit in <b>b</b> to 1. */
|
|
|
-static INLINE void
|
|
|
+static inline void
|
|
|
bitarray_set(bitarray_t *b, int bit)
|
|
|
{
|
|
|
b[bit >> BITARRAY_SHIFT] |= (1u << (bit & BITARRAY_MASK));
|
|
|
}
|
|
|
/** Set the <b>bit</b>th bit in <b>b</b> to 0. */
|
|
|
-static INLINE void
|
|
|
+static inline void
|
|
|
bitarray_clear(bitarray_t *b, int bit)
|
|
|
{
|
|
|
b[bit >> BITARRAY_SHIFT] &= ~ (1u << (bit & BITARRAY_MASK));
|
|
|
}
|
|
|
/** Return true iff <b>bit</b>th bit in <b>b</b> is nonzero. NOTE: does
|
|
|
* not necessarily return 1 on true. */
|
|
|
-static INLINE unsigned int
|
|
|
+static inline unsigned int
|
|
|
bitarray_is_set(bitarray_t *b, int bit)
|
|
|
{
|
|
|
return b[bit >> BITARRAY_SHIFT] & (1u << (bit & BITARRAY_MASK));
|
|
@@ -645,7 +645,7 @@ typedef struct {
|
|
|
|
|
|
#define BIT(n) ((n) & set->mask)
|
|
|
/** Add the digest <b>digest</b> to <b>set</b>. */
|
|
|
-static INLINE void
|
|
|
+static inline void
|
|
|
digestset_add(digestset_t *set, const char *digest)
|
|
|
{
|
|
|
const uint64_t x = siphash24g(digest, 20);
|
|
@@ -661,7 +661,7 @@ digestset_add(digestset_t *set, const char *digest)
|
|
|
|
|
|
/** If <b>digest</b> is in <b>set</b>, return nonzero. Otherwise,
|
|
|
* <em>probably</em> return zero. */
|
|
|
-static INLINE int
|
|
|
+static inline int
|
|
|
digestset_contains(const digestset_t *set, const char *digest)
|
|
|
{
|
|
|
const uint64_t x = siphash24g(digest, 20);
|
|
@@ -689,33 +689,33 @@ double find_nth_double(double *array, int n_elements, int nth);
|
|
|
int32_t find_nth_int32(int32_t *array, int n_elements, int nth);
|
|
|
uint32_t find_nth_uint32(uint32_t *array, int n_elements, int nth);
|
|
|
long find_nth_long(long *array, int n_elements, int nth);
|
|
|
-static INLINE int
|
|
|
+static inline int
|
|
|
median_int(int *array, int n_elements)
|
|
|
{
|
|
|
return find_nth_int(array, n_elements, (n_elements-1)/2);
|
|
|
}
|
|
|
-static INLINE time_t
|
|
|
+static inline time_t
|
|
|
median_time(time_t *array, int n_elements)
|
|
|
{
|
|
|
return find_nth_time(array, n_elements, (n_elements-1)/2);
|
|
|
}
|
|
|
-static INLINE double
|
|
|
+static inline double
|
|
|
median_double(double *array, int n_elements)
|
|
|
{
|
|
|
return find_nth_double(array, n_elements, (n_elements-1)/2);
|
|
|
}
|
|
|
-static INLINE uint32_t
|
|
|
+static inline uint32_t
|
|
|
median_uint32(uint32_t *array, int n_elements)
|
|
|
{
|
|
|
return find_nth_uint32(array, n_elements, (n_elements-1)/2);
|
|
|
}
|
|
|
-static INLINE int32_t
|
|
|
+static inline int32_t
|
|
|
median_int32(int32_t *array, int n_elements)
|
|
|
{
|
|
|
return find_nth_int32(array, n_elements, (n_elements-1)/2);
|
|
|
}
|
|
|
|
|
|
-static INLINE uint32_t
|
|
|
+static inline uint32_t
|
|
|
third_quartile_uint32(uint32_t *array, int n_elements)
|
|
|
{
|
|
|
return find_nth_uint32(array, n_elements, (n_elements*3)/4);
|