lint

Author: lemire

include/roaring/array_util.h

@@ -42,8 +42,8 @@ namespace internal {
  *     if ( x<0 ) then inserting ikey at position -x-1 in array (insuring that
  * array[-x-1]=ikey) keys the array sorted.
  */
-croaring_really_inline int32_t binarySearch(const uint16_t *array, int32_t lenarray,
-                            uint16_t ikey) {
+croaring_really_inline int32_t binarySearch(const uint16_t *array,
+                                            int32_t lenarray, uint16_t ikey) {
     int32_t low = 0;
     int32_t high = lenarray - 1;
     while (low <= high) {

include/roaring/containers/array.h

@@ -339,13 +339,14 @@ static inline bool array_container_remove(array_container_t *arr,
 }
 
 /* Check whether x is present.  */
-static croaring_really_inline bool array_container_contains(const array_container_t *arr, uint16_t pos) {
+croaring_really_inline bool array_container_contains(
+    const array_container_t *arr, uint16_t pos) {
     const int32_t gap = 16;
     const uint16_t *carr = arr->array;
     int32_t cardinality = arr->cardinality;
     if (cardinality < gap) {
-      for (int32_t j = 0; j < cardinality; j++) {
-          if (carr[j] >= pos) return carr[j] == pos;
+        for (int32_t j = 0; j < cardinality; j++) {
+            if (carr[j] >= pos) return carr[j] == pos;
         }
         return false;
     }
@@ -365,7 +366,8 @@ static croaring_really_inline bool array_container_contains(const array_containe
         uint16x8_t needle = vdupq_n_u16(pos);
         uint16x8_t v0 = vld1q_u16(blk);
         uint16x8_t v1 = vld1q_u16(blk + 8);
-        uint16x8_t hit = vorrq_u16(vceqq_u16(v0, needle), vceqq_u16(v1, needle));
+        uint16x8_t hit =
+            vorrq_u16(vceqq_u16(v0, needle), vceqq_u16(v1, needle));
         return vmaxvq_u16(hit) != 0;
 #elif defined(CROARING_IS_X64)
         __m128i needle = _mm_set1_epi16((short)pos);
@@ -375,15 +377,16 @@ static croaring_really_inline bool array_container_contains(const array_containe
                                    _mm_cmpeq_epi16(v1, needle));
         return _mm_movemask_epi8(hit) != 0;
 #else
-        // SWAR fallback: compare 16 values in parallel using bitwise operations.
+        // SWAR fallback: compare 16 values in parallel using bitwise
+        // operations.
         uint64_t broadcast = 0x0001000100010001ULL * pos;
-        const uint64_t ones  = 0x0001000100010001ULL;
+        const uint64_t ones = 0x0001000100010001ULL;
         const uint64_t highs = 0x8000800080008000ULL;
 
         uint64_t w0, w1, w2, w3;
-        memcpy(&w0, blk,      sizeof(uint64_t));
-        memcpy(&w1, blk + 4,  sizeof(uint64_t));
-        memcpy(&w2, blk + 8,  sizeof(uint64_t));
+        memcpy(&w0, blk, sizeof(uint64_t));
+        memcpy(&w1, blk + 4, sizeof(uint64_t));
+        memcpy(&w2, blk + 8, sizeof(uint64_t));
         memcpy(&w3, blk + 12, sizeof(uint64_t));
 
         // XOR: a lane is zero iff that element equals x

include/roaring/containers/bitset.h

@@ -189,8 +189,8 @@ static inline bool bitset_container_remove(bitset_container_t *bitset,
 }
 
 /* Get the value of the ith bit.  */
-croaring_really_inline bool bitset_container_get(const bitset_container_t *bitset,
-                                 uint16_t pos) {
+croaring_really_inline bool bitset_container_get(
+    const bitset_container_t *bitset, uint16_t pos) {
     const uint64_t word = bitset->words[pos >> 6];
     return (word >> (pos & 63)) & 1;
 }
@@ -228,8 +228,8 @@ static inline bool bitset_container_get_range(const bitset_container_t *bitset,
 }
 
 /* Check whether `bitset' is present in `array'.  Calls bitset_container_get. */
-croaring_really_inline bool bitset_container_contains(const bitset_container_t *bitset,
-                                      uint16_t pos) {
+croaring_really_inline bool bitset_container_contains(
+    const bitset_container_t *bitset, uint16_t pos) {
     return bitset_container_get(bitset, pos);
 }
 

include/roaring/containers/run.h

@@ -108,8 +108,9 @@ static inline void recoverRoomAtIndex(run_container_t *run, uint16_t index) {
 /**
  * Good old binary search through rle data
  */
-croaring_really_inline int32_t interleavedBinarySearch(const rle16_t *array, int32_t lenarray,
-                                       uint16_t ikey) {
+croaring_really_inline int32_t interleavedBinarySearch(const rle16_t *array,
+                                                       int32_t lenarray,
+                                                       uint16_t ikey) {
     int32_t low = 0;
     int32_t high = lenarray - 1;
     while (low <= high) {
@@ -257,7 +258,8 @@ static inline bool run_container_remove(run_container_t *run, uint16_t pos) {
 }
 
 /* Check whether `pos' is present in `run'.  */
-croaring_really_inline bool run_container_contains(const run_container_t *run, uint16_t pos) {
+croaring_really_inline bool run_container_contains(const run_container_t *run,
+                                                   uint16_t pos) {
     int32_t index = interleavedBinarySearch(run->runs, run->n_runs, pos);
     if (index >= 0) return true;
     index = -index - 2;  // points to preceding value, possibly -1

include/roaring/portability.h

@@ -77,16 +77,16 @@ extern "C" {  // portability definitions are in global scope, not a namespace
 #ifndef __restrict__
 #define __restrict__ __restrict
 #endif  // __restrict__
-#ifndef croaring_really_inline 
-#define  __forceinline
+#ifndef croaring_really_inline
+#define __forceinline
 #endif  // croaring_really_inline
 #endif  // CROARING_REGULAR_VISUAL_STUDIO
 
 #if defined(__GNUC__) || defined(__clang__)
 #ifndef croaring_really_inline
 #define croaring_really_inline __attribute__((always_inline)) inline
 #endif  // croaring_really_inline
-#endif // defined(__GNUC__) || defined(__clang__)
+#endif  // defined(__GNUC__) || defined(__clang__)
 
 #ifndef croaring_really_inline
 #define croaring_really_inline inline

include/roaring/roaring.h

@@ -475,7 +475,8 @@ bool roaring_bitmap_remove_checked(roaring_bitmap_t *r, uint32_t x);
 /**
  * Check if value is present
  */
-croaring_really_inline bool roaring_bitmap_contains(const roaring_bitmap_t *r, uint32_t val) {
+croaring_really_inline bool roaring_bitmap_contains(const roaring_bitmap_t *r,
+                                                    uint32_t val) {
     // For performance reasons, this function is inline and uses internal
     // functions directly.
 #ifdef __cplusplus

include/roaring/roaring_array.h

@@ -90,24 +90,26 @@ void ra_clear_containers(roaring_array_t *ra);
 /**
  * Get the index corresponding to a 16-bit key
  */
-croaring_really_inline int32_t ra_get_index(const roaring_array_t *ra, uint16_t x) {
+croaring_really_inline int32_t ra_get_index(const roaring_array_t *ra,
+                                            uint16_t x) {
     if ((ra->size == 0) || ra->keys[ra->size - 1] == x) return ra->size - 1;
     return binarySearch(ra->keys, (int32_t)ra->size, x);
 }
 
 /**
  * Retrieves the container at index i, filling in the typecode
  */
-croaring_really_inline container_t *ra_get_container_at_index(const roaring_array_t *ra,
-                                              uint16_t i, uint8_t *typecode) {
+croaring_really_inline container_t *ra_get_container_at_index(
+    const roaring_array_t *ra, uint16_t i, uint8_t *typecode) {
     *typecode = ra->typecodes[i];
     return ra->containers[i];
 }
 
 /**
  * Retrieves the key at index i
  */
-croaring_really_inline uint16_t ra_get_key_at_index(const roaring_array_t *ra, uint16_t i) {
+croaring_really_inline uint16_t ra_get_key_at_index(const roaring_array_t *ra,
+                                                    uint16_t i) {
     return ra->keys[i];
 }