translate the example from C++ to C99

examples/ex_1.c

@@ -1,180 +1,204 @@
-#include <sparsemap.h>
 #include <assert.h>
+#include <stdarg.h>
 #include <stdio.h>
 
-using namespace sparsemap;
+#include "../include/sparsemap.h"
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#define __diag(format, ...) \
+  __diag_(__FILE__, __LINE__, __func__, format, ##__VA_ARGS__)
+#pragma GCC diagnostic pop
+void __attribute__((format(printf, 4, 5))) __diag_(const char *file,
+  int line, const char *func, const char *format, ...)
+{
+  va_list args;
+  va_start(args, format);
+  fprintf(stderr, "%s:%d:%s(): ", file, line, func);
+  vfprintf(stderr, format, args);
+  va_end(args);
+}
+
+// NOTE: currently, this code serves as a sample and unittest.
 
-//
-// this code serves as a sample but also as a unittest.
-//
 int main() {
   int size = 4;
-  setbuf(stdout, 0); // disable printf() buffering 
+  __diag("Please wait a moment...");
-  printf("Please wait a moment.");
 #if 1
   uint8_t buffer[1024];
   uint8_t buffer2[1024];
+  sparsemap_t *map = sparsemap(buffer, sizeof(buffer), 0);
+  assert(sparsemap_get_size(map) == size);
+  sparsemap_set(map, 0, true);
+  assert(sparsemap_get_size(map) == size + 4 + 8 + 8);
+  assert(sparsemap_is_set(map, 0) == true);
+  assert(sparsemap_get_size(map) == size + 4 + 8 + 8);
+  assert(sparsemap_is_set(map, 1) == false);
+  sparsemap_set(map, 0, false);
+  assert(sparsemap_get_size(map) == size);
 
-  SparseMap<uint32_t, uint64_t> sm;
+  sparsemap_clear(map);
-  sm.create(buffer, sizeof(buffer));
+  sparsemap_set(map, 64, true);
-  assert(sm.get_size() == size);
+  assert(sparsemap_is_set(map, 64) == true);
-  sm.set(0, true);
+  assert(sparsemap_get_size(map) == size + 4 + 8 + 8);
-  assert(sm.get_size() == size + 4 + 8 + 8);
-  assert(sm.is_set(0) == true);
-  assert(sm.get_size() == size + 4 + 8 + 8);
-  assert(sm.is_set(1) == false);
-  sm.set(0, false);
-  assert(sm.get_size() == size);
 
-  sm.clear();
+  sparsemap_clear(map);
-  sm.set(64, true);
+  __diag(".");
-  assert(sm.is_set(64) == true);
-  assert(sm.get_size() == size + 4 + 8 + 8);
-
-  sm.clear();
-  printf(".");
 
   // set [0..100000]
   for (int i = 0; i < 100000; i++) {
-    assert(sm.is_set(i) == false);
+    assert(sparsemap_is_set(map, i) == false);
-    sm.set(i, true);
+    sparsemap_set(map, i, true);
     if (i > 5) {
-      for (int j = i - 5; j <= i; j++)
+      for (int j = i - 5; j <= i; j++) {
-        assert(sm.is_set(j) == true);
+        assert(sparsemap_is_set(map, j) == true);
+      }
     }
 
-    assert(sm.is_set(i) == true);
+    assert(sparsemap_is_set(map, i) == true);
   }
 
-  printf(".");
+  __diag(".");
 
-  for (int i = 0; i < 100000; i++)
+  for (int i = 0; i < 100000; i++) {
-    assert(sm.is_set(i) == true);
+    assert(sparsemap_is_set(map, i) == true);
+  }
 
   // unset [0..10000]
   for (int i = 0; i < 10000; i++) {
-    assert(sm.is_set(i) == true);
+    assert(sparsemap_is_set(map, i) == true);
-    sm.set(i, false);
+    sparsemap_set(map, i, false);
-    assert(sm.is_set(i) == false);
+    assert(sparsemap_is_set(map, i) == false);
   }
 
-  for (int i = 0; i < 10000; i++)
+  for (int i = 0; i < 10000; i++) {
-    assert(sm.is_set(i) == false);
+    assert(sparsemap_is_set(map, i) == false);
+  }
 
-  sm.clear();
+  sparsemap_clear(map);
-  printf(".");
+  __diag(".");
 
   // set [10000..0]
   for (int i = 10000; i >= 0; i--) {
-    assert(sm.is_set(i) == false);
+    assert(sparsemap_is_set(map, i) == false);
-    sm.set(i, true);
+    sparsemap_set(map, i, true);
-    assert(sm.is_set(i) == true);
+    assert(sparsemap_is_set(map, i) == true);
   }
 
-  for (int i = 10000; i >= 0; i--)
+  for (int i = 10000; i >= 0; i--) {
-    assert(sm.is_set(i) == true);
+    assert(sparsemap_is_set(map, i) == true);
-  printf(".");
+    __diag(".");
+  }
 
   // open and compare
-  SparseMap<uint32_t, uint64_t> sm2;
+  sparsemap_t *sm2 = sparsemap_open(buffer, sizeof(buffer));
-  sm2.open(buffer, sizeof(buffer));
+  for (int i = 0; i < 10000; i++) {
-  for (int i = 0; i < 10000; i++)
+    assert(sparsemap_is_set(sm2, i) == sparsemap_is_set(map, i));
-    assert(sm2.is_set(i) == sm.is_set(i));
+  }
 
   // unset [10000..0]
   for (int i = 10000; i >= 0; i--) {
-    assert(sm.is_set(i) == true);
+    assert(sparsemap_is_set(map, i) == true);
-    sm.set(i, false);
+    sparsemap_set(map, i, false);
-    assert(sm.is_set(i) == false);
+    assert(sparsemap_is_set(map, i) == false);
   }
 
-  for (int i = 10000; i >= 0; i--)
+  for (int i = 10000; i >= 0; i--) {
-    assert(sm.is_set(i) == false);
+    assert(sparsemap_is_set(map, i) == false);
+  }
 
-  printf(".");
+  __diag(".");
-  sm.clear();
+  sparsemap_clear(map);
 
-  sm.set(0, true);
+  sparsemap_set(map, 0, true);
-  sm.set(2048 * 2 + 1, true);
+  sparsemap_set(map, 2048 * 2 + 1, true);
-  assert(sm.is_set(0) == true);
+  assert(sparsemap_is_set(map, 0) == true);
-  assert(sm.is_set(2048 * 2 + 0) == false);
+  assert(sparsemap_is_set(map, 2048 * 2 + 0) == false);
-  assert(sm.is_set(2048 * 2 + 1) == true);
+  assert(sparsemap_is_set(map, 2048 * 2 + 1) == true);
-  assert(sm.is_set(2048 * 2 + 2) == false);
+  assert(sparsemap_is_set(map, 2048 * 2 + 2) == false);
-  sm.set(2048, true);
+  sparsemap_set(map, 2048, true);
-  assert(sm.is_set(0) == true);
+  assert(sparsemap_is_set(map, 0) == true);
-  assert(sm.is_set(2047) == false);
+  assert(sparsemap_is_set(map, 2047) == false);
-  assert(sm.is_set(2048) == true);
+  assert(sparsemap_is_set(map, 2048) == true);
-  assert(sm.is_set(2049) == false);
+  assert(sparsemap_is_set(map, 2049) == false);
-  assert(sm.is_set(2048 * 2 + 2) == false);
+  assert(sparsemap_is_set(map, 2048 * 2 + 2) == false);
-  assert(sm.is_set(2048 * 2 + 0) == false);
+  assert(sparsemap_is_set(map, 2048 * 2 + 0) == false);
-  assert(sm.is_set(2048 * 2 + 1) == true);
+  assert(sparsemap_is_set(map, 2048 * 2 + 1) == true);
-  assert(sm.is_set(2048 * 2 + 2) == false);
+  assert(sparsemap_is_set(map, 2048 * 2 + 2) == false);
 
-  sm.clear();
+  sparsemap_clear(map);
-  printf(".");
+  __diag(".");
 
-  for (int i = 0; i < 100000; i++)
+  for (int i = 0; i < 100000; i++) {
-    sm.set(i, true);
+    sparsemap_set(map, i, true);
-  for (int i = 0; i < 100000; i++)
+  }
-    assert(sm.select(i) == (unsigned)i);
+  for (int i = 0; i < 100000; i++) {
+    assert(sparsemap_select(map, i) == (unsigned)i);
+  }
 
-  sm.clear();
+  sparsemap_clear(map);
-  printf(".");
+  __diag(".");
 
-  for (int i = 1; i < 513; i++)
+  for (int i = 1; i < 513; i++) {
-    sm.set(i, true);
+    sparsemap_set(map, i, true);
-  for (int i = 1; i < 513; i++)
+  }
-    assert(sm.select(i - 1) == (unsigned)i);
+  for (int i = 1; i < 513; i++) {
+    assert(sparsemap_select(map, i - 1) == (unsigned)i);
+  }
 
-  sm.clear();
+  sparsemap_clear(map);
-  printf(".");
+  __diag(".");
 
-  for (int i = 0; i < 8; i++)
+  for (size_t i = 0; i < 8; i++) {
-    sm.set(i * 10, true);
+    sparsemap_set(map, i * 10, true);
-  for (int i = 0; i < 8; i++)
+  }
-    assert(sm.select(i) == (unsigned)i * 10);
+  for (size_t i = 0; i < 8; i++) {
+    assert(sparsemap_select(map, i) == i * 10);
+  }
 
   // split and move, aligned to MiniMap capacity
-  sm2.create(buffer2, sizeof(buffer2));
+  sm2 = sparsemap(buffer2, sizeof(buffer2), 0);
-  sm.clear();
+  sparsemap_clear(sm2);
-  for (int i = 0; i < 2048 * 2; i++)
+  for (int i = 0; i < 2048 * 2; i++) {
-    sm.set(i, true);
+    sparsemap_set(map, i, true);
-  sm.split(2048, &sm2);
+  }
+  sparsemap_split(map, 2048, sm2);
   for (int i = 0; i < 2048; i++) {
-    assert(sm.is_set(i) == true);
+    assert(sparsemap_is_set(map, i) == true);
-    assert(sm2.is_set(i) == false);
+    assert(sparsemap_is_set(sm2, i) == false);
   }
   for (int i = 2048; i < 2048 * 2; i++) {
-    assert(sm.is_set(i) == false);
+    assert(sparsemap_is_set(map, i) == false);
-    assert(sm2.is_set(i) == true);
+    assert(sparsemap_is_set(sm2, i) == true);
   }
-  printf(".");
+  __diag(".");
 
   // split and move, aligned to BitVector capacity
-  sm2.create(buffer2, sizeof(buffer2));
+  sm2 = sparsemap(buffer2, sizeof(buffer2), 0);
-  sm.clear();
+  sparsemap_clear(map);
-  for (int i = 0; i < 2048 * 3; i++)
+  for (int i = 0; i < 2048 * 3; i++) {
-    sm.set(i, true);
+    sparsemap_set(map, i, true);
-  sm.split(64, &sm2);
+  }
+  sparsemap_split(map, 64, sm2);
   for (int i = 0; i < 64; i++) {
-    assert(sm.is_set(i) == true);
+    assert(sparsemap_is_set(map, i) == true);
-    assert(sm2.is_set(i) == false);
+    assert(sparsemap_is_set(sm2, i) == false);
   }
   for (int i = 64; i < 2048 * 3; i++) {
-    assert(sm.is_set(i) == false);
+    assert(sparsemap_is_set(map, i) == false);
-    assert(sm2.is_set(i) == true);
+    assert(sparsemap_is_set(sm2, i) == true);
   }
 
-  printf("ok\n");
+  __diag("ok\n");
 #else
   //
   // This code was used to create the lookup table for
   // sparsemap::MiniMap<>::calc_vector_size()
   //
-  printf("   ");
+  __diag("   ");
   for (unsigned int ch = 0; ch <= 0xff; ch++) {
     if (ch > 0 && ch % 16 == 0)
-      printf("\n   ");
+      __diag("\n   ");
 
     /*
     // check if value is invalid (contains 2#01)
@@ -182,8 +206,8 @@ int main() {
         || (ch & (0x3 << 2)) >> 2 == 1
         || (ch & (0x3 << 4)) >> 4 == 1
         || (ch & (0x3 << 6)) >> 6 == 1) {
-      //printf("%d: -1\n", (int)ch);
+      //__diag("%d: -1\n", (int)ch);
-      printf(" -1,");
+      __diag(" -1,");
       continue;
     }
     */
@@ -198,8 +222,8 @@ int main() {
       size++;
     if ((ch & (0x3 << 6)) >> 6 == 2)
       size++;
-    //printf("%u: %d\n", (unsigned int)ch, size);
+    //__diag("%u: %d\n", (unsigned int)ch, size);
-    printf("  %d,", size);
+    __diag("  %d,", size);
   }
 #endif
 }

include/sparsemap.h

@@ -80,6 +80,9 @@ sparsemap_t *sparsemap(uint8_t *data, size_t size, size_t used);
 /* Initialize sparsemap_t with data. */
 void sparsemap_init(sparsemap_t *map, uint8_t *data, size_t size, size_t used);
 
+/* Clears the whole buffer. */
+void sparsemap_clear(sparsemap_t *map);
+
 /* Opens an existing sparsemap at the specified buffer. */
 sparsemap_t *sparsemap_open(uint8_t *data, size_t data_size);
 

src/sparsemap.c

@@ -31,10 +31,10 @@
 #ifdef SPARSEMAP_DIAGNOSTIC
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wvariadic-macros"
-#define __skip_diag(format, ...) \
+#define __sm_diag(format, ...) \
-  __skip_diag_(__FILE__, __LINE__, __func__, format, ##__VA_ARGS__)
+  __sm_diag_(__FILE__, __LINE__, __func__, format, ##__VA_ARGS__)
 #pragma GCC diagnostic pop
-void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file,
+void __attribute__((format(printf, 4, 5))) __sm_diag_(const char *file,
   int line, const char *func, const char *format, ...)
 {
   va_list args;
@@ -44,7 +44,7 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file,
   va_end(args);
 }
 #else
-#define __skip_diag(file, line, func, format, ...) ((void)0)
+#define __sm_diag(file, line, func, format, ...) ((void)0)
 #endif
 
 #ifndef SPARSEMAP_ASSERT
@@ -633,6 +633,16 @@ __sm_get_size_impl(sparsemap_t *map)
   return (SM_SIZEOF_OVERHEAD + p - start);
 }
 
+/**
+ * Returns the aligned offset (aligned to sm_bitvec_t capacity).
+ */
+static sm_idx_t
+__sm_get_aligned_offset(size_t idx)
+{
+  const size_t capacity = SM_BITS_PER_VECTOR;
+  return ((idx / capacity) * capacity);
+}
+
 /**
  * Returns the byte offset of a __sm_chunk_t in m_data
  */
@@ -664,16 +674,6 @@ __sm_get_chunk_map_offset(sparsemap_t *map, size_t idx)
   return ((ssize_t)(p - start));
 }
 
-/**
- * Returns the aligned offset (aligned to sm_bitvec_t capacity).
- */
-static sm_idx_t
-__sm_get_aligned_offset(size_t idx)
-{
-  const size_t capacity = SM_BITS_PER_VECTOR;
-  return ((idx / capacity) * capacity);
-}
-
 /**
  * Returns the aligned offset (aligned to __sm_chunk_t capacity).
  */
@@ -734,10 +734,10 @@ __sm_remove_data(sparsemap_t *map, size_t offset, size_t gap_size)
 }
 
 /**
- *  Clears the whole buffer
+*  Clears the whole buffer
- */
+*/
 void
-__sm_clear(sparsemap_t *map)
+sparsemap_clear(sparsemap_t *map)
 {
   map->m_data_used = SM_SIZEOF_OVERHEAD;
   __sm_set_chunk_map_count(map, 0);
@@ -765,7 +765,7 @@ sparsemap_init(sparsemap_t *map, uint8_t *data, size_t size, size_t used)
   map->m_data = data;
   map->m_data_used = used;
   map->m_data_size = size == 0 ? UINT64_MAX : size;
-  __sm_clear(map);
+  sparsemap_clear(map);
 }
 
 /**
@@ -807,7 +807,7 @@ sparsemap_get_range_size(sparsemap_t *map)
 bool
 sparsemap_is_set(sparsemap_t *map, size_t idx)
 {
-  __sm_assert(get_size() >= SM_SIZEOF_OVERHEAD);
+  __sm_assert(sparsemap_get_size(map) >= SM_SIZEOF_OVERHEAD);
 
   /* Get the __sm_chunk_t which manages this index */
   ssize_t offset = __sm_get_chunk_map_offset(map, idx);
@@ -839,7 +839,7 @@ sparsemap_is_set(sparsemap_t *map, size_t idx)
 void
 sparsemap_set(sparsemap_t *map, size_t idx, bool value)
 {
-  __sm_assert(get_size() >= SM_SIZEOF_OVERHEAD);
+  __sm_assert(sparsemap_get_size(map) >= SM_SIZEOF_OVERHEAD);
 
   /* Get the __sm_chunk_t which manages this index */
   ssize_t offset = __sm_get_chunk_map_offset(map, idx);
@@ -968,7 +968,7 @@ sparsemap_set(sparsemap_t *map, size_t idx, bool value)
 #endif
     break;
   }
-  __sm_assert(get_size() >= SM_SIZEOF_OVERHEAD);
+  __sm_assert(sparsemap_get_size(map) >= SM_SIZEOF_OVERHEAD);
 }
 
 /**