Merge branch 'master' of github.com:RoaringBitmap/CRoaring

Author: lemire

.github/workflows/emscripten.yml

@@ -0,0 +1,19 @@
+name: emscripten
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+      - uses: mymindstorm/setup-emsdk@6ab9eb1bda2574c4ddb79809fc9247783eaf9021 # v14
+      - name: Verify
+        run: emcc -v
+      - name: Checkout
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v3.6.0
+      - name: Configure
+        run: emcmake cmake -B build
+      - name: Build # We build but do not test 
+        run: cmake --build build

CMakeLists.txt

@@ -108,15 +108,15 @@ configure_file ("${CMAKE_CURRENT_SOURCE_DIR}/tests/config.h.in"
 #################################
 
 add_subdirectory(src)
-if(ENABLE_ROARING_TESTS)
+if(ENABLE_ROARING_TESTS AND NOT EMSCRIPTEN)
   if(CMAKE_SIZEOF_VOID_P EQUAL 8) # we only include the benchmarks on 64-bit systems.
     add_subdirectory(benchmarks)
   endif()
   add_subdirectory(tests)
 endif()
 find_program(BASH bash)
 
-if(ENABLE_ROARING_TESTS AND BASH)
+if(ENABLE_ROARING_TESTS AND BASH AND NOT EMSCRIPTEN)
   message(STATUS "Amalgamation tests enabled")
   set(CROARING_SINGLEHEADER_FILES
     ${CMAKE_CURRENT_BINARY_DIR}/amalgamation_demo.c

cpp/roaring64map.hh

@@ -11,6 +11,7 @@
 
 #include <algorithm>
 #include <cinttypes>  // PRIu64 macro
+#include <climits>    // for UINT64_MAX
 #include <cstdarg>    // for va_list handling in bitmapOf()
 #include <cstdio>     // for std::printf() in the printf() method
 #include <cstring>    // for std::memcpy()
@@ -781,6 +782,9 @@ class Roaring64Map {
      * Returns true if the bitmap is full (cardinality is max uint64_t + 1).
      */
     bool isFull() const {
+        // This function is somewhat absurd. A full 64-bit bitmap would surely
+        // exceed our memory limits.
+#if SIZE_MAX >= UINT64_MAX
         // only bother to check if map is fully saturated
         //
         // we put std::numeric_limits<>::max/min in parentheses
@@ -793,6 +797,11 @@ class Roaring64Map {
                                      return roaring_map_entry.second.isFull();
                                  })
                    : false;
+#else
+        // if SIZE_MAX < UINT64_MAX, then we cannot represent a full bitmap
+        // in a 64-bit integer, so we return false.
+        return false;
+#endif
     }
 
     /**

src/containers/run.c

@@ -157,7 +157,7 @@ void run_container_offset(const run_container_t *c, container_t **loc,
         lo = run_container_create_given_capacity(lo_cap);
         memcpy(lo->runs, c->runs, lo_cap * sizeof(rle16_t));
         lo->n_runs = lo_cap;
-        for (int i = 0; i < lo_cap; ++i) {
+        for (unsigned int i = 0; i < lo_cap; ++i) {
             lo->runs[i].value += offset;
         }
         *loc = (container_t *)lo;
@@ -167,7 +167,7 @@ void run_container_offset(const run_container_t *c, container_t **loc,
         hi = run_container_create_given_capacity(hi_cap);
         memcpy(hi->runs, c->runs + pivot, hi_cap * sizeof(rle16_t));
         hi->n_runs = hi_cap;
-        for (int i = 0; i < hi_cap; ++i) {
+        for (unsigned int i = 0; i < hi_cap; ++i) {
             hi->runs[i].value += offset;
         }
         *hic = (container_t *)hi;

src/roaring64.c

@@ -129,8 +129,8 @@ static void extend_containers(roaring64_bitmap_t *r) {
         new_capacity = 5 * r->capacity / 4;
     }
     uint64_t increase = new_capacity - r->capacity;
-    r->containers =
-        roaring_realloc(r->containers, new_capacity * sizeof(container_t *));
+    r->containers = (container_t **)roaring_realloc(
+        r->containers, new_capacity * sizeof(container_t *));
     memset(r->containers + r->capacity, 0, increase * sizeof(container_t *));
     r->capacity = new_capacity;
 }
@@ -987,8 +987,8 @@ size_t roaring64_bitmap_shrink_to_fit(roaring64_bitmap_t *r) {
     }
     uint64_t new_capacity = r->first_free;
     if (new_capacity < r->capacity) {
-        r->containers = roaring_realloc(r->containers,
-                                        new_capacity * sizeof(container_t *));
+        r->containers = (container_t **)roaring_realloc(
+            r->containers, new_capacity * sizeof(container_t *));
         freed += (r->capacity - new_capacity) * sizeof(container_t *);
         r->capacity = new_capacity;
     }
@@ -2454,7 +2454,7 @@ roaring64_bitmap_t *roaring64_bitmap_frozen_view(const char *buf,
     maxbytes -= sizeof(r->capacity);
 
     r->containers =
-        (container_t *)roaring_malloc(r->capacity * sizeof(container_t *));
+        (container_t **)roaring_malloc(r->capacity * sizeof(container_t *));
 
     // Container element counts.
     if (maxbytes < r->capacity * sizeof(uint16_t)) {

tests/CMakeLists.txt

@@ -61,3 +61,79 @@ endif()
 
 get_directory_property(parent_dir PARENT_DIRECTORY)
 configure_file("${parent_dir}/tools/cmake/CTestCustom.cmake" "${CMAKE_BINARY_DIR}")
+
+
+# The amalgamate_demo and amalgamate_demo_cpp do not catch errors from our
+# quick start instructions.
+
+if(BASH_EXECUTABLE)
+  set(AMALGAMATION_DIR "${CMAKE_BINARY_DIR}/tests/amalgamation")
+  file(MAKE_DIRECTORY "${AMALGAMATION_DIR}")
+
+  add_custom_command(
+    OUTPUT "${AMALGAMATION_DIR}/roaring.c" "${AMALGAMATION_DIR}/roaring.h" "${AMALGAMATION_DIR}/roaring.hh"
+    COMMAND "${BASH_EXECUTABLE}" "${CMAKE_SOURCE_DIR}/amalgamation.sh" "${AMALGAMATION_DIR}"
+    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+    COMMENT "Running amalgamation.sh to generate amalgamated files"
+    VERBATIM
+  )
+
+  add_custom_target(amalgamation ALL
+    DEPENDS "${AMALGAMATION_DIR}/roaring.c" "${AMALGAMATION_DIR}/roaring.h" "${AMALGAMATION_DIR}/roaring.hh"
+  )
+
+  set(AMALG_C "${AMALGAMATION_DIR}/demo_amalg_c.c")
+  file(WRITE "${AMALG_C}" "
+#include <stdio.h>
+#include <stdlib.h>
+#include \"roaring.c\"
+int main() {
+    roaring_bitmap_t *r1 = roaring_bitmap_create();
+    for (uint32_t i = 100; i < 1000; i++) roaring_bitmap_add(r1, i);
+    printf(\"cardinality = %d\\n\", (int) roaring_bitmap_get_cardinality(r1));
+    roaring_bitmap_free(r1);
+
+    bitset_t *b = bitset_create();
+    for (int k = 0; k < 1000; ++k) {
+            bitset_set(b, 3 * k);
+    }
+    printf(\"%zu \\n\", bitset_count(b));
+    bitset_free(b);
+    return EXIT_SUCCESS;
+}
+")
+
+  add_executable(amalg_c_demo "${AMALG_C}")
+  add_dependencies(amalg_c_demo amalgamation)
+  target_include_directories(amalg_c_demo PRIVATE "${AMALGAMATION_DIR}")
+
+  set(AMALG_CPP "${AMALGAMATION_DIR}/demo_amalg_cpp.cpp")
+  file(WRITE "${AMALG_CPP}" "
+#include <iostream>
+#include \"roaring.hh\" // the amalgamated roaring.hh includes roaring64map.hh
+#include \"roaring.c\"
+int main() {
+    roaring::Roaring r1;
+    for (uint32_t i = 100; i < 1000; i++) {
+        r1.add(i);
+    }
+    std::cout << \"cardinality = \" << r1.cardinality() << std::endl;
+
+    roaring::Roaring64Map r2;
+    for (uint64_t i = 18000000000000000100ull; i < 18000000000000001000ull; i++) {
+        r2.add(i);
+    }
+    std::cout << \"cardinality = \" << r2.cardinality() << std::endl;
+    return 0;
+}
+")
+
+  add_executable(amalg_cpp_demo "${AMALG_CPP}")
+  add_dependencies(amalg_cpp_demo amalgamation)
+  target_include_directories(amalg_cpp_demo PRIVATE "${AMALGAMATION_DIR}")
+
+  add_test(NAME amalg_c_demo_test COMMAND amalg_c_demo)
+  add_test(NAME amalg_cpp_demo_test COMMAND amalg_cpp_demo)
+else()
+  message(STATUS "Bash executable not found, skipping amalgamation tests.")
+endif()

tools/cmake/FindCTargets.cmake

@@ -1,6 +1,6 @@
 include(${PROJECT_SOURCE_DIR}/tools/cmake/Import.cmake)
 set(BUILD_STATIC_LIB ON)
-if (ENABLE_ROARING_TESTS)
+if (ENABLE_ROARING_TESTS AND NOT EMSCRIPTEN)
   if(ROARING_USE_CPM)
     CPMAddPackage(
       NAME cmocka