Revert "[3party][succinct] Fixed uint64_t <-> size_t warnings."

9 files changed, 67 insertions, 65 deletions

diff --git a/3party/succinct/bit_vector.hpp b/3party/succinct/bit_vector.hpp
index 8b6e157ec0..5ca0e7db96 100644
--- a/3party/succinct/bit_vector.hpp
+++ b/3party/succinct/bit_vector.hpp
@@ -13,7 +13,7 @@ namespace succinct {
     namespace detail {
         inline size_t words_for(uint64_t n)
         {
-            return util::to_size(util::ceil_div(n, 64));
+            return util::ceil_div(n, 64);
         }
     }
 
@@ -52,7 +52,7 @@ namespace succinct {
         }
 
         inline void set(uint64_t pos, bool b) {
-            size_t const word = util::to_size(pos / 64);
+            uint64_t word = pos / 64;
             uint64_t pos_in_word = pos % 64;
 
             m_bits[word] &= ~(uint64_t(1) << pos_in_word);
@@ -66,7 +66,7 @@ namespace succinct {
             assert(len == 64 || (bits >> len) == 0);
             if (!len) return;
             uint64_t mask = (len == 64) ? uint64_t(-1) : ((uint64_t(1) << len) - 1);
-            size_t const word = util::to_size(pos / 64);
+            uint64_t word = pos / 64;
             uint64_t pos_in_word = pos % 64;
 
             m_bits[word] &= ~(mask << pos_in_word);
@@ -79,7 +79,7 @@ namespace succinct {
             }
         }
 
-        inline void append_bits(uint64_t bits, uint8_t len)
+        inline void append_bits(uint64_t bits, size_t len)
         {
             // check there are no spurious bits
             assert(len == 64 || (bits >> len) == 0);
@@ -99,7 +99,7 @@ namespace succinct {
 
         inline void zero_extend(uint64_t n) {
             m_size += n;
-            size_t const needed = detail::words_for(m_size) - m_bits.size();
+            uint64_t needed = detail::words_for(m_size) - m_bits.size();
             if (needed) {
                 m_bits.insert(m_bits.end(), needed, 0);
                 m_cur_word = &m_bits.back();
@@ -113,7 +113,7 @@ namespace succinct {
                 n -= 64;
             }
             if (n) {
-                append_bits(uint64_t(-1) >> (64 - n), static_cast<uint8_t>(n));
+                append_bits(uint64_t(-1) >> (64 - n), n);
             }
         }
 
@@ -242,7 +242,7 @@ namespace succinct {
 
         inline bool operator[](uint64_t pos) const {
             assert(pos < m_size);
-            size_t const block = util::to_size(pos / 64);
+            uint64_t block = pos / 64;
             assert(block < m_bits.size());
             uint64_t shift = pos % 64;
             return (m_bits[block] >> shift) & 1;
@@ -253,7 +253,7 @@ namespace succinct {
             if (!len) {
                 return 0;
             }
-            size_t const block = util::to_size(pos / 64);
+            uint64_t block = pos / 64;
             uint64_t shift = pos % 64;
             uint64_t mask = -(len == 64) | ((1ULL << len) - 1);
             if (shift + len <= 64) {
@@ -267,7 +267,7 @@ namespace succinct {
         inline uint64_t get_word(uint64_t pos) const
         {
             assert(pos < size());
-            size_t const block = util::to_size(pos / 64);
+            uint64_t block = pos / 64;
             uint64_t shift = pos % 64;
             uint64_t word = m_bits[block] >> shift;
             if (shift && block + 1 < m_bits.size()) {
@@ -288,7 +288,7 @@ namespace succinct {
 
         inline uint64_t predecessor0(uint64_t pos) const {
             assert(pos < m_size);
-            size_t block = util::to_size(pos / 64);
+            uint64_t block = pos / 64;
             uint64_t shift = 64 - pos % 64 - 1;
             uint64_t word = ~m_bits[block];
             word = (word << shift) >> shift;
@@ -303,7 +303,7 @@ namespace succinct {
 
         inline uint64_t successor0(uint64_t pos) const {
             assert(pos < m_size);
-            size_t block = util::to_size(pos / 64);
+            uint64_t block = pos / 64;
             uint64_t shift = pos % 64;
             uint64_t word = (~m_bits[block] >> shift) << shift;
 
@@ -318,7 +318,7 @@ namespace succinct {
 
         inline uint64_t predecessor1(uint64_t pos) const {
             assert(pos < m_size);
-            size_t block = util::to_size(pos / 64);
+            uint64_t block = pos / 64;
             uint64_t shift = 64 - pos % 64 - 1;
             uint64_t word = m_bits[block];
             word = (word << shift) >> shift;
@@ -333,7 +333,7 @@ namespace succinct {
 
         inline uint64_t successor1(uint64_t pos) const {
             assert(pos < m_size);
-            size_t block = util::to_size(pos / 64);
+            uint64_t block = pos / 64;
             uint64_t shift = pos % 64;
             uint64_t word = (m_bits[block] >> shift) << shift;
 
@@ -363,7 +363,7 @@ namespace succinct {
                 , m_buf(0)
                 , m_avail(0)
             {
-                m_bv->data().prefetch(util::to_size(m_pos / 64));
+                m_bv->data().prefetch(m_pos / 64);
             }
 
             inline bool next()
diff --git a/3party/succinct/darray.hpp b/3party/succinct/darray.hpp
index c2ed3cc108..79920f2f8d 100644
--- a/3party/succinct/darray.hpp
+++ b/3party/succinct/darray.hpp
@@ -24,7 +24,7 @@ namespace succinct {
                 std::vector<uint16_t> subblock_inventory;
                 std::vector<uint64_t> overflow_positions;
 
-                for (size_t word_idx = 0; word_idx < data.size(); ++word_idx) {
+                for (uint64_t word_idx = 0; word_idx < data.size(); ++word_idx) {
                     uint64_t cur_pos = word_idx * 64;
                     uint64_t cur_word = WordGetter()(data, word_idx);
                     unsigned long l;
@@ -74,20 +74,22 @@ namespace succinct {
             inline uint64_t select(bit_vector const& bv, uint64_t idx) const
             {
                 assert(idx < num_positions());
-                int64_t block_pos = m_block_inventory[util::to_size(idx / block_size)];
+                uint64_t block = idx / block_size;
+                int64_t block_pos = m_block_inventory[block];
                 if (block_pos < 0) {
                     uint64_t overflow_pos = uint64_t(-block_pos - 1);
-                    return m_overflow_positions[util::to_size(overflow_pos + (idx % block_size))];
+                    return m_overflow_positions[overflow_pos + (idx % block_size)];
                 }
 
-                uint64_t start_pos = uint64_t(block_pos) + m_subblock_inventory[util::to_size(idx / subblock_size)];
+                uint64_t subblock = idx / subblock_size;
+                uint64_t start_pos = uint64_t(block_pos) + m_subblock_inventory[subblock];
                 uint64_t reminder = idx % subblock_size;
                 mapper::mappable_vector<uint64_t> const& data = bv.data();
 
                 if (!reminder) {
                     return start_pos;
                 } else {
-                    size_t word_idx = util::to_size(start_pos / 64);
+                    uint64_t word_idx = start_pos / 64;
                     uint64_t word_shift = start_pos % 64;
                     uint64_t word = WordGetter()(data, word_idx) & (uint64_t(-1) << word_shift);
 
diff --git a/3party/succinct/darray64.hpp b/3party/succinct/darray64.hpp
index 522dc181c7..07fad2bd9d 100644
--- a/3party/succinct/darray64.hpp
+++ b/3party/succinct/darray64.hpp
@@ -12,7 +12,7 @@ namespace succinct {
                 : n_ones(0)
             {}
 
-            void append1(uint8_t skip0 = 0)
+            void append1(uint64_t skip0 = 0)
             {
                 bits.append_bits(0, skip0);
                 bits.push_back(1);
@@ -21,8 +21,7 @@ namespace succinct {
                     block_inventory.push_back(bits.size() - 1);
                 }
                 if (n_ones % subblock_size == 0) {
-                    size_t const block = util::to_size(n_ones / block_size);
-                    subblock_inventory.push_back(uint16_t(bits.size() - 1 - block_inventory[block]));
+                    subblock_inventory.push_back(uint16_t(bits.size() - 1 - block_inventory[n_ones / block_size]));
                 }
 
                 n_ones += 1;
@@ -77,22 +76,25 @@ namespace succinct {
         uint64_t select(uint64_t idx) const
         {
             assert(idx < num_ones());
-            uint64_t block_pos = m_block_inventory[util::to_size(idx / block_size)];
-            uint64_t start_pos = block_pos + m_subblock_inventory[util::to_size(idx / subblock_size)];
+            uint64_t block = idx / block_size;
+            uint64_t block_pos = m_block_inventory[block];
+
+            uint64_t subblock = idx / subblock_size;
+            uint64_t start_pos = block_pos + m_subblock_inventory[subblock];
             uint64_t reminder = idx % subblock_size;
 
             if (!reminder) {
                 return start_pos;
             } else {
-                size_t word_idx = util::to_size(start_pos / 64);
+                uint64_t word_idx = start_pos / 64;
                 uint64_t word_shift = start_pos % 64;
-                uint64_t word = m_bits[word_idx] & (uint64_t(-1) << word_shift);
+                uint64_t word = m_bits.data()[word_idx] & (uint64_t(-1) << word_shift);
 
                 while (true) {
                     uint64_t popcnt = broadword::popcount(word);
                     if (reminder < popcnt) break;
                     reminder -= popcnt;
-                    word = m_bits[++word_idx];
+                    word = m_bits.data()[++word_idx];
                 }
 
                 return 64 * word_idx + broadword::select_in_word(word, reminder);
diff --git a/3party/succinct/elias_fano_compressed_list.hpp b/3party/succinct/elias_fano_compressed_list.hpp
index c509c4a3dd..51d1848710 100644
--- a/3party/succinct/elias_fano_compressed_list.hpp
+++ b/3party/succinct/elias_fano_compressed_list.hpp
@@ -47,7 +47,7 @@ namespace succinct {
             return ((uint64_t(1) << l) | m_bits.get_bits(r.first, l)) - 1;
         }
 
-        uint64_t size() const
+        size_t size() const
         {
             return m_ef.num_ones() - 1;
         }
diff --git a/3party/succinct/gamma_vector.hpp b/3party/succinct/gamma_vector.hpp
index b3a77559cc..7b31a249d2 100644
--- a/3party/succinct/gamma_vector.hpp
+++ b/3party/succinct/gamma_vector.hpp
@@ -99,8 +99,8 @@ namespace succinct {
         value_type next()
         {
             assert(m_idx <= m_c->size());
-            uint64_t next_pos = m_high_bits_enumerator.next();
-            uint64_t l = next_pos - m_pos - 1;
+            size_t next_pos = m_high_bits_enumerator.next();
+            size_t l = next_pos - m_pos - 1;
             m_pos = next_pos;
             uint64_t chunk = m_low_bits_enumerator.take(l);
             uint64_t val = (chunk | (uint64_t(1) << (l))) - 1;
diff --git a/3party/succinct/mappable_vector.hpp b/3party/succinct/mappable_vector.hpp
index 3a968a99a6..0c1c9a76ea 100644
--- a/3party/succinct/mappable_vector.hpp
+++ b/3party/succinct/mappable_vector.hpp
@@ -9,6 +9,8 @@
 #include <boost/lambda/bind.hpp>
 #include <boost/lambda/construct.hpp>
 
+#include <stdint.h>
+
 #include "intrinsics.hpp"
 
 namespace succinct { namespace mapper {
@@ -84,7 +86,7 @@ namespace succinct { namespace mapper {
             mappable_vector(from).swap(*this);
         }
 
-        size_t size() const {
+        uint64_t size() const {
             return m_size;
         }
 
@@ -96,7 +98,7 @@ namespace succinct { namespace mapper {
             return m_data + m_size;
         }
 
-        inline T const& operator[](size_t i) const {
+        inline T const& operator[](uint64_t i) const {
             assert(i < m_size);
             return m_data[i];
         }
@@ -115,7 +117,7 @@ namespace succinct { namespace mapper {
 
     protected:
         const T* m_data;
-        size_t m_size;
+        uint64_t m_size;
         deleter_t m_deleter;
     };
 
diff --git a/3party/succinct/mapper.hpp b/3party/succinct/mapper.hpp
index c71196b110..a39873307d 100644
--- a/3party/succinct/mapper.hpp
+++ b/3party/succinct/mapper.hpp
@@ -107,7 +107,7 @@ namespace succinct { namespace mapper {
                 return *this;
             }
 
-            uint64_t written() const {
+            size_t written() const {
                 return m_written;
             }
 
@@ -255,7 +255,7 @@ namespace succinct { namespace mapper {
     }
 
     template <typename T>
-    uint64_t freeze(T& val, std::ofstream& fout, uint64_t flags = 0, const char* friendly_name = "<TOP>")
+    size_t freeze(T& val, std::ofstream& fout, uint64_t flags = 0, const char* friendly_name = "<TOP>")
     {
         detail::freeze_visitor freezer(fout, flags);
         freezer(val, friendly_name);
@@ -263,7 +263,7 @@ namespace succinct { namespace mapper {
     }
 
     template <typename T>
-    uint64_t freeze(T& val, const char* filename, uint64_t flags = 0, const char* friendly_name = "<TOP>")
+    size_t freeze(T& val, const char* filename, uint64_t flags = 0, const char* friendly_name = "<TOP>")
     {
         std::ofstream fout;
         fout.exceptions(std::ifstream::failbit);
diff --git a/3party/succinct/rs_bit_vector.hpp b/3party/succinct/rs_bit_vector.hpp
index 232bf5c24b..1197ffb100 100644
--- a/3party/succinct/rs_bit_vector.hpp
+++ b/3party/succinct/rs_bit_vector.hpp
@@ -58,7 +58,7 @@ namespace succinct {
             uint64_t r = sub_block_rank(sub_block);
             uint64_t sub_left = pos % 64;
             if (sub_left) {
-                r += broadword::popcount(m_bits[util::to_size(sub_block)] << (64 - sub_left));
+                r += broadword::popcount(m_bits[sub_block] << (64 - sub_left));
             }
             return r;
         }
@@ -71,18 +71,19 @@ namespace succinct {
             using broadword::popcount;
             using broadword::select_in_word;
             assert(n < num_ones());
-            size_t a = 0;
-            size_t b = num_blocks();
+            uint64_t a = 0;
+            uint64_t b = num_blocks();
             if (m_select_hints.size()) {
-                size_t const chunk = util::to_size(n / select_ones_per_hint);
+                uint64_t chunk = n / select_ones_per_hint;
                 if (chunk != 0) {
-                    a = util::to_size(m_select_hints[chunk - 1]);
+                    a = m_select_hints[chunk - 1];
                 }
-                b = util::to_size(m_select_hints[chunk] + 1);
+                b = m_select_hints[chunk] + 1;
             }
 
+            uint64_t block = 0;
             while (b - a > 1) {
-                size_t const mid = a + (b - a) / 2;
+                uint64_t mid = a + (b - a) / 2;
                 uint64_t x = block_rank(mid);
                 if (x <= n) {
                     a = mid;
@@ -90,7 +91,7 @@ namespace succinct {
                     b = mid;
                 }
             }
-            size_t const block = a;
+            block = a;
 
             assert(block < num_blocks());
             uint64_t block_offset = block * block_size;
@@ -104,7 +105,7 @@ namespace succinct {
             cur_rank += sub_ranks >> (7 - sub_block_offset) * 9 & 0x1FF;
             assert(cur_rank <= n);
 
-            size_t const word_offset = util::to_size(block_offset + sub_block_offset);
+            uint64_t word_offset = block_offset + sub_block_offset;
             return word_offset * 64 + select_in_word(m_bits[word_offset], n - cur_rank);
         }
 
@@ -113,18 +114,19 @@ namespace succinct {
             using broadword::popcount;
             using broadword::select_in_word;
             assert(n < num_zeros());
-            size_t a = 0;
-            size_t b = num_blocks();
+            uint64_t a = 0;
+            uint64_t b = num_blocks();
             if (m_select0_hints.size()) {
-                size_t const chunk = util::to_size(n / select_zeros_per_hint);
+                uint64_t chunk = n / select_zeros_per_hint;
                 if (chunk != 0) {
-                    a = util::to_size(m_select0_hints[chunk - 1]);
+                    a = m_select0_hints[chunk - 1];
                 }
-                b = util::to_size(m_select0_hints[chunk] + 1);
+                b = m_select0_hints[chunk] + 1;
             }
 
+            uint64_t block = 0;
             while (b - a > 1) {
-                size_t const mid = a + (b - a) / 2;
+                uint64_t mid = a + (b - a) / 2;
                 uint64_t x = block_rank0(mid);
                 if (x <= n) {
                     a = mid;
@@ -132,7 +134,7 @@ namespace succinct {
                     b = mid;
                 }
             }
-            size_t const block = a;
+            block = a;
 
             assert(block < num_blocks());
             uint64_t block_offset = block * block_size;
@@ -145,34 +147,34 @@ namespace succinct {
             cur_rank0 += sub_ranks >> (7 - sub_block_offset) * 9 & 0x1FF;
             assert(cur_rank0 <= n);
 
-            size_t const word_offset = util::to_size(block_offset + sub_block_offset);
+            uint64_t word_offset = block_offset + sub_block_offset;
             return word_offset * 64 + select_in_word(~m_bits[word_offset], n - cur_rank0);
         }
 
     protected:
 
-        inline size_t num_blocks() const {
+        inline uint64_t num_blocks() const {
             return m_block_rank_pairs.size() / 2 - 1;
         }
 
-        inline uint64_t block_rank(size_t block) const {
+        inline uint64_t block_rank(uint64_t block) const {
             return m_block_rank_pairs[block * 2];
         }
 
         inline uint64_t sub_block_rank(uint64_t sub_block) const {
             uint64_t r = 0;
-            size_t const block = util::to_size(sub_block / block_size);
+            uint64_t block = sub_block / block_size;
             r += block_rank(block);
             uint64_t left = sub_block % block_size;
             r += sub_block_ranks(block) >> ((7 - left) * 9) & 0x1FF;
             return r;
         }
 
-        inline uint64_t sub_block_ranks(size_t block) const {
+        inline uint64_t sub_block_ranks(uint64_t block) const {
             return m_block_rank_pairs[block * 2 + 1];
         }
 
-        inline uint64_t block_rank0(size_t block) const {
+        inline uint64_t block_rank0(uint64_t block) const {
             return block * block_size * 64 - m_block_rank_pairs[block * 2];
         }
 
diff --git a/3party/succinct/util.hpp b/3party/succinct/util.hpp
index 5cdea07c9d..c8c079fcf4 100644
--- a/3party/succinct/util.hpp
+++ b/3party/succinct/util.hpp
@@ -10,13 +10,7 @@
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/iostreams/device/mapped_file.hpp>
 
-namespace succinct { namespace util
-{
-    inline size_t to_size(uint64_t n)
-    {
-        assert(n <= std::numeric_limits<size_t>::max());
-        return static_cast<size_t>(n);
-    }
+namespace succinct { namespace util {
 
     inline void trim_newline_chars(std::string& s)
     {