util: make bson_next_power_of_two() take a size_t.

Author: Christian Hergert

src/bson/bson-json.c

@@ -295,7 +295,7 @@ _bson_json_buf_ensure (bson_json_buf_t *buf, /* IN */
    if (buf->n_bytes < len) {
       bson_free (buf->buf);
 
-      buf->n_bytes = bson_next_power_of_two ((uint32_t)len);
+      buf->n_bytes = bson_next_power_of_two (len);
       buf->buf = bson_malloc (buf->n_bytes);
    }
 }

src/bson/bson-string.c

@@ -63,7 +63,7 @@ bson_string_new (const char *str) /* IN */
    ret->alloc = ret->len + 1;
 
    if (!bson_is_power_of_two (ret->alloc)) {
-      ret->alloc = bson_next_power_of_two (ret->alloc);
+      ret->alloc = bson_next_power_of_two ((size_t)ret->alloc);
    }
 
    BSON_ASSERT (ret->alloc >= 1);
@@ -151,7 +151,7 @@ bson_string_append (bson_string_t *string, /* IN */
    if ((string->alloc - string->len - 1) < len) {
       string->alloc += len;
       if (!bson_is_power_of_two (string->alloc)) {
-         string->alloc = bson_next_power_of_two (string->alloc);
+         string->alloc = bson_next_power_of_two ((size_t)string->alloc);
       }
       string->str = bson_realloc (string->str, string->alloc);
    }
@@ -306,7 +306,7 @@ bson_string_truncate (bson_string_t *string, /* IN */
    }
 
    if (!bson_is_power_of_two (alloc)) {
-      alloc = bson_next_power_of_two (alloc);
+      alloc = bson_next_power_of_two ((size_t)alloc);
    }
 
    string->str = bson_realloc (string->str, alloc);

src/bson/bson-types.h

@@ -488,15 +488,18 @@ BSON_STATIC_ASSERT (sizeof (bson_error_t) == 512);
  *
  * Returns: The next power of 2 from @v.
  */
-static BSON_INLINE uint32_t
-bson_next_power_of_two (uint32_t v)
+static BSON_INLINE size_t
+bson_next_power_of_two (size_t v)
 {
    v--;
    v |= v >> 1;
    v |= v >> 2;
    v |= v >> 4;
    v |= v >> 8;
    v |= v >> 16;
+#if BSON_WORD_SIZE == 64
+   v |= v >> 32;
+#endif
    v++;
 
    return v;

src/bson/bson.c

@@ -86,7 +86,7 @@ static const uint8_t gZero;
 
 static bool
 _bson_impl_inline_grow (bson_impl_inline_t *impl, /* IN */
-                        uint32_t            size) /* IN */
+                        size_t              size) /* IN */
 {
    bson_impl_alloc_t *alloc = (bson_impl_alloc_t *)impl;
    uint8_t *data;
@@ -96,7 +96,7 @@ _bson_impl_inline_grow (bson_impl_inline_t *impl, /* IN */
    BSON_ASSERT (!(impl->flags & BSON_FLAG_RDONLY));
    BSON_ASSERT (!(impl->flags & BSON_FLAG_CHILD));
 
-   if ((impl->len + size) <= sizeof impl->data) {
+   if (((size_t)impl->len + size) <= sizeof impl->data) {
       return true;
    }
 
@@ -143,25 +143,25 @@ _bson_impl_inline_grow (bson_impl_inline_t *impl, /* IN */
 
 static bool
 _bson_impl_alloc_grow (bson_impl_alloc_t *impl, /* IN */
-                       uint32_t           size) /* IN */
+                       size_t             size) /* IN */
 {
-   uint32_t req;
+   size_t req;
 
    BSON_ASSERT (impl);
 
    /*
     * Determine how many bytes we need for this document in the buffer
     * including necessary trailing bytes for parent documents.
     */
-   req = (uint32_t)(impl->offset + impl->len + size + impl->depth);
+   req = (impl->offset + impl->len + size + impl->depth);
 
    if (req <= *impl->buflen) {
       return true;
    }
 
    req = bson_next_power_of_two (req);
 
-   if ((int32_t)req <= INT32_MAX && impl->realloc) {
+   if ((req <= INT32_MAX) && impl->realloc) {
       *impl->buf = impl->realloc (*impl->buf, req, impl->realloc_func_ctx);
       *impl->buflen = req;
       return true;
@@ -2005,7 +2005,7 @@ bson_copy_to (const bson_t *src,
    }
 
    data = _bson_data (src);
-   len = bson_next_power_of_two (src->len);
+   len = bson_next_power_of_two ((size_t)src->len);
 
    adst = (bson_impl_alloc_t *)dst;
    adst->flags = BSON_FLAG_STATIC;

tests/test-bson.c

@@ -1356,6 +1356,43 @@ test_bson_has_field (void)
 }
 
 
+static void
+test_next_power_of_two (void)
+{
+   size_t s;
+
+   s = 3;
+   s = bson_next_power_of_two (s);
+   assert (s == 4);
+
+   s = 4;
+   s = bson_next_power_of_two (s);
+   assert (s == 4);
+
+   s = 33;
+   s = bson_next_power_of_two (s);
+   assert (s == 64);
+
+   s = 91;
+   s = bson_next_power_of_two (s);
+   assert (s == 128);
+
+#if BSON_WORD_SIZE == 64
+   s = 4294967296LL;
+   s = bson_next_power_of_two (s);
+   assert (s == 4294967296LL);
+
+   s = 4294967297LL;
+   s = bson_next_power_of_two (s);
+   assert (s == 8589934592LL);
+
+   s = 17179901952LL;
+   s = bson_next_power_of_two (s);
+   assert (s == 34359738368LL);
+#endif
+}
+
+
 void
 test_bson_install (TestSuite *suite)
 {
@@ -1409,4 +1446,6 @@ test_bson_install (TestSuite *suite)
    TestSuite_Add (suite, "/bson/clear", test_bson_clear);
    TestSuite_Add (suite, "/bson/destroy_with_steal", test_bson_destroy_with_steal);
    TestSuite_Add (suite, "/bson/has_field", test_bson_has_field);
+
+   TestSuite_Add (suite, "/util/next_power_of_two", test_next_power_of_two);
 }