initial commit

crypto/common/bitstring.h

@@ -0,0 +1,662 @@
+/*
+    This file is part of TON Blockchain Library.
+
+    TON Blockchain Library is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    TON Blockchain Library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with TON Blockchain Library.  If not, see <http://www.gnu.org/licenses/>.
+
+    Copyright 2017-2019 Telegram Systems LLP
+*/
+#pragma once
+#include "common/refcnt.hpp"
+#include <utility>
+#include <array>
+#include <string>
+#include <ostream>
+#include <cstdlib>
+#include "td/utils/bits.h"
+
+namespace td {
+template <class Pt>
+struct BitPtrGen;
+
+typedef BitPtrGen<unsigned char> BitPtr;
+typedef BitPtrGen<const unsigned char> ConstBitPtr;
+
+struct BitstringError {};
+
+namespace bitstring {
+
+void bits_memcpy(unsigned char* to, int to_offs, const unsigned char* from, int from_offs, std::size_t bit_count);
+void bits_memcpy(BitPtr to, ConstBitPtr from, std::size_t bit_count);
+void bits_memset(unsigned char* to, int to_offs, bool val, std::size_t bit_count);
+void bits_memset(BitPtr to, bool val, std::size_t bit_count);
+int bits_memcmp(const unsigned char* bs1, int bs1_offs, const unsigned char* bs2, int bs2_offs, std::size_t bit_count,
+                std::size_t* same_upto = 0);
+int bits_memcmp(ConstBitPtr bs1, ConstBitPtr bs2, std::size_t bit_count, std::size_t* same_upto = 0);
+int bits_lexcmp(const unsigned char* bs1, int bs1_offs, std::size_t bs1_bit_count, const unsigned char* bs2,
+                int bs2_offs, std::size_t bs2_bit_count);
+int bits_lexcmp(ConstBitPtr bs1, std::size_t bs1_bit_count, ConstBitPtr bs2, std::size_t bs2_bit_count);
+std::size_t bits_memscan(const unsigned char* ptr, int offs, std::size_t bit_count, bool cmp_to);
+std::size_t bits_memscan_rev(const unsigned char* ptr, int offs, std::size_t bit_count, bool cmp_to);
+std::size_t bits_memscan(ConstBitPtr bs, std::size_t bit_count, bool cmp_to);
+std::size_t bits_memscan_rev(ConstBitPtr bs, std::size_t bit_count, bool cmp_to);
+void bits_store_long_top(unsigned char* to, int to_offs, unsigned long long val, unsigned top_bits);
+void bits_store_long_top(BitPtr to, unsigned long long val, unsigned top_bits);
+void bits_store_long(BitPtr to, unsigned long long val, unsigned bits);
+unsigned long long bits_load_long_top(const unsigned char* from, int from_offs, unsigned top_bits);
+unsigned long long bits_load_long_top(ConstBitPtr from, unsigned top_bits);
+long long bits_load_long(ConstBitPtr from, unsigned bits);
+unsigned long long bits_load_ulong(ConstBitPtr from, unsigned bits);
+long parse_bitstring_hex_literal(unsigned char* buff, std::size_t buff_size, const char* str, const char* str_end);
+long parse_bitstring_binary_literal(BitPtr buff, std::size_t buff_size, const char* str, const char* str_end);
+
+void bits_sha256(BitPtr to, ConstBitPtr from, std::size_t size);
+
+std::string bits_to_binary(const unsigned char* ptr, int offs, std::size_t len);
+std::string bits_to_binary(ConstBitPtr bs, std::size_t len);
+std::string bits_to_hex(const unsigned char* ptr, int offs, std::size_t len);
+std::string bits_to_hex(ConstBitPtr bs, std::size_t len);
+
+}  // namespace bitstring
+
+template <class Pt>
+struct BitPtrGen {
+  Pt* ptr;
+  int offs;
+  BitPtrGen(Pt* _ptr, int _offs = 0) : ptr(_ptr), offs(_offs) {
+  }
+  template <class Pt2>
+  BitPtrGen(BitPtrGen<Pt2> val) : ptr(val.ptr), offs(val.offs) {
+  }
+  BitPtrGen& operator+=(int _offs) {
+    offs += _offs;
+    return *this;
+  }
+  BitPtrGen& operator-=(int _offs) {
+    offs -= _offs;
+    return *this;
+  }
+  void advance(int _offs) {
+    offs += _offs;
+  }
+  bool byte_aligned() const {
+    return !(offs & 7);
+  }
+  Pt* get_byte_ptr() const {
+    return ptr + (offs >> 3);
+  }
+  void copy_from(BitPtrGen<const Pt> from, unsigned size) const {
+    bitstring::bits_memcpy(*this, from, size);
+  }
+  BitPtrGen& concat(BitPtrGen<const Pt> from, unsigned size) {
+    bitstring::bits_memcpy(*this, from, size);
+    offs += size;
+    return *this;
+  }
+  template <typename T>
+  void copy_from(const T& from) const {
+    copy_from(from.bits(), from.size());
+  }
+  template <typename T>
+  BitPtrGen& concat(const T& from) {
+    return concat(from.bits(), from.size());
+  }
+  void fill(bool bit, unsigned size) {
+    bitstring::bits_memset(*this, bit, size);
+  }
+  BitPtrGen& concat_same(bool bit, unsigned size) {
+    bitstring::bits_memset(*this, bit, size);
+    offs += size;
+    return *this;
+  }
+  int compare(BitPtrGen<const Pt> other, std::size_t size, std::size_t* same_upto = nullptr) const {
+    return bitstring::bits_memcmp(*this, other, size, same_upto);
+  }
+  bool equals(BitPtrGen<const Pt> other, std::size_t size) const {
+    return !bitstring::bits_memcmp(*this, other, size);
+  }
+  std::size_t scan(bool value, std::size_t len) const {
+    return bitstring::bits_memscan(*this, len, value);
+  }
+  long long get_int(unsigned bits) const {
+    return bitstring::bits_load_long(*this, bits);
+  }
+  unsigned long long get_uint(unsigned bits) const {
+    return bitstring::bits_load_ulong(*this, bits);
+  }
+  void store_uint(unsigned long long val, unsigned n) const {
+    bitstring::bits_store_long(*this, val, n);
+  }
+  void store_int(long long val, unsigned n) const {
+    bitstring::bits_store_long(*this, val, n);
+  }
+  BitPtrGen operator+(int _offs) const {
+    return BitPtrGen{ptr, offs + _offs};
+  }
+  BitPtrGen operator-(int _offs) const {
+    return BitPtrGen{ptr, offs - _offs};
+  }
+  BitPtrGen operator++() {
+    ++offs;
+    return *this;
+  }
+  BitPtrGen operator--() {
+    --offs;
+    return *this;
+  }
+  BitPtrGen operator++(int) {
+    return BitPtrGen{ptr, offs++};
+  }
+  BitPtrGen operator--(int) {
+    return BitPtrGen{ptr, offs--};
+  }
+  bool is_null() const {
+    return !ptr;
+  }
+  bool not_null() const {
+    return ptr;
+  }
+  class BitSelector {
+    Pt* ptr;
+    unsigned char mask;
+
+   public:
+    BitSelector(Pt* _ptr, int offs) {
+      ptr = _ptr + (offs >> 3);
+      mask = (unsigned char)(0x80 >> (offs & 7));
+    }
+    bool clear() {
+      *ptr = (unsigned char)(*ptr & ~mask);
+      return false;
+    }
+    bool set() {
+      *ptr = (unsigned char)(*ptr | mask);
+      return true;
+    }
+    bool operator=(bool val) {
+      return val ? set() : clear();
+    }
+    operator bool() const {
+      return *ptr & mask;
+    }
+  };
+  BitSelector operator*() const {
+    return BitSelector{ptr, offs};
+  }
+  BitSelector operator[](int i) const {
+    return BitSelector{ptr, offs + i};
+  }
+  std::string to_hex(std::size_t len) const {
+    return bitstring::bits_to_hex(*this, len);
+  }
+  std::string to_binary(std::size_t len) const {
+    return bitstring::bits_to_binary(*this, len);
+  }
+};
+
+template <class Rf, class Pt>
+class BitSliceGen {
+  Rf ref;
+  Pt* ptr;
+  unsigned offs, len;
+
+ public:
+  struct BitSliceError {};
+  BitSliceGen() : ref(), ptr(0), offs(0), len(0) {
+  }
+  BitSliceGen(Rf _ref, Pt* _ptr, int _offs, unsigned _len)
+      : ref(std::move(_ref)), ptr(_ptr + (_offs >> 3)), offs(_offs & 7), len(_len) {
+  }
+  BitSliceGen(const BitSliceGen& bs, unsigned _offs, unsigned _len);
+  BitSliceGen(BitSliceGen&& bs, unsigned _offs, unsigned _len);
+  BitSliceGen(Pt* _ptr, unsigned _len) : ref(), ptr(_ptr), offs(0), len(_len) {
+  }
+  ~BitSliceGen() {
+  }
+  Pt* get_ptr() const {
+    return ptr;
+  }
+  BitPtrGen<Pt> bits() const {
+    return BitPtrGen<Pt>{ptr, (int)offs};
+  }
+  bool is_valid() const {
+    return ptr != 0;
+  }
+  unsigned char cur_byte() const {
+    return *ptr;
+  }
+  unsigned get_offs() const {
+    return offs;
+  }
+  unsigned size() const {
+    return len;
+  }
+  unsigned byte_size() const {
+    return (offs + len + 7) >> 3;
+  }
+  void ensure_throw(bool cond) const {
+    if (!cond) {
+      throw BitSliceError{};
+    }
+  }
+  BitSliceGen& assign(Rf _ref, Pt* _ptr, unsigned _offs, unsigned _len);
+  void forget() {
+    ref.clear();
+    ptr = 0;
+    offs = len = 0;
+  }
+  bool operator[](unsigned i) const {
+    i += offs;
+    return ptr[i >> 3] & (0x80 >> (i & 7));
+  }
+  bool at(unsigned i) const {
+    ensure_throw(i < len);
+    return operator[](i);
+  }
+  bool advance_bool(unsigned bits);
+  bool set_size_bool(unsigned bits) {
+    if (bits > len) {
+      return false;
+    }
+    len = bits;
+    return true;
+  }
+  BitSliceGen& advance(unsigned bits) {
+    ensure_throw(advance_bool(bits));
+    return *this;
+  }
+  BitSliceGen& set_size(unsigned bits) {
+    ensure_throw(set_size_bool(bits));
+    return *this;
+  }
+  BitSliceGen subslice(unsigned from, unsigned bits) const & {
+    return BitSliceGen(*this, from, bits);
+  }
+  BitSliceGen subslice(unsigned from, unsigned bits) && {
+    return BitSliceGen(*this, from, bits);
+  }
+  void copy_to(BitPtr to) const {
+    bitstring::bits_memcpy(to, bits(), size());
+  }
+  int compare(ConstBitPtr other) const {
+    return bitstring::bits_memcmp(bits(), other, size());
+  }
+  bool operator==(ConstBitPtr other) const {
+    return !compare(other);
+  }
+  bool operator!=(ConstBitPtr other) const {
+    return compare(other);
+  }
+  std::string to_binary() const {
+    return bitstring::bits_to_binary(ptr, offs, len);
+  }
+  std::string to_hex() const {
+    return bitstring::bits_to_hex(ptr, offs, len);
+  }
+  void dump(std::ostream& stream, bool nocr = false) const {
+    stream << "[" << offs << "," << len << "]";
+    if (!nocr) {
+      stream << std::endl;
+    }
+  }
+
+ protected:
+  inline Pt& cur_byte_w() const {
+    return *ptr;
+  }
+};
+
+template <class Rf, class Pt>
+BitSliceGen<Rf, Pt>::BitSliceGen(const BitSliceGen<Rf, Pt>& bs, unsigned from, unsigned bits) : ref() {
+  if (from >= bs.size() || bits > bs.size() - from) {
+    ptr = 0;
+    offs = len = 0;
+    return;
+  }
+  //bs.dump(std::cout, true);
+  //std::cout << ".subslice(" << from << "," << bits << ") = ";
+  ref = bs.ref;
+  offs = bs.offs + from;
+  ptr = bs.ptr + (offs >> 3);
+  offs &= 7;
+  len = bits;
+  //dump(std::cout);
+}
+
+template <class Rf, class Pt>
+BitSliceGen<Rf, Pt>::BitSliceGen(BitSliceGen&& bs, unsigned from, unsigned bits) : ref() {
+  if (from >= bs.size() || bits > bs.size() - from) {
+    ptr = 0;
+    offs = len = 0;
+    return;
+  }
+  ref = std::move(bs.ref);
+  offs = bs.offs + from;
+  ptr = bs.ptr + (offs >> 3);
+  offs &= 7;
+  len = bits;
+}
+
+template <class Rf, class Pt>
+BitSliceGen<Rf, Pt>& BitSliceGen<Rf, Pt>::assign(Rf _ref, Pt* _ptr, unsigned _offs, unsigned _len) {
+  ref = std::move(_ref);
+  ptr = _ptr + (_offs >> 3);
+  offs = (_offs & 7);
+  len = _len;
+  return *this;
+}
+
+template <class Rf, class Pt>
+inline bool BitSliceGen<Rf, Pt>::advance_bool(unsigned bits) {
+  if (len < bits) {
+    return false;
+  }
+  len -= bits;
+  offs += bits;
+  ptr += (offs >> 3);
+  offs &= 7;
+  return true;
+}
+
+typedef BitSliceGen<RefAny, const unsigned char> BitSlice;
+
+static inline std::string to_hex(const BitSlice& bs) {
+  return bs.to_hex();
+}
+
+static inline std::string to_binary(const BitSlice& bs) {
+  return bs.to_binary();
+}
+
+class BitSliceWrite : public BitSliceGen<RefAny, unsigned char> {
+ public:
+  struct LengthMismatch {};
+  BitSliceWrite(RefAny _ref, unsigned char* _ptr, unsigned _offs, unsigned _len)
+      : BitSliceGen<RefAny, unsigned char>(_ref, _ptr, _offs, _len) {
+  }
+  BitSliceWrite() : BitSliceGen<RefAny, unsigned char>() {
+  }
+  BitSliceWrite(unsigned char* _ptr, unsigned _len) : BitSliceGen<RefAny, unsigned char>(_ptr, _len) {
+  }
+  operator BitSlice&() {
+    return *reinterpret_cast<BitSlice*>(this);
+  }
+  operator const BitSlice&() const {
+    return *reinterpret_cast<const BitSlice*>(this);
+  }
+  const BitSliceWrite& operator=(const BitSlice& bs) const;
+  const BitSliceWrite& operator=(bool val) const;
+};
+
+class BitString : public CntObject {
+  unsigned char* ptr;
+  unsigned offs, len, bytes_alloc;
+
+ public:
+  BitString() : ptr(0), offs(0), len(0), bytes_alloc(0) {
+  }
+  explicit BitString(const BitSlice& bs, unsigned reserve_bits = 0);
+  explicit BitString(unsigned reserve_bits);
+
+  BitString(const BitString&) = delete;
+  BitString& operator=(const BitString&) = delete;
+  BitString(BitString&&) = delete;
+  BitString& operator=(BitString&&) = delete;
+  ~BitString() {
+    if (ptr) {
+      std::free(ptr);
+    }
+  }
+  operator BitSlice() const;
+  BitString* make_copy() const override;
+  unsigned size() const {
+    return len;
+  }
+  unsigned byte_size() const {
+    return (offs + len + 7) >> 3;
+  }
+  ConstBitPtr cbits() const {
+    return ConstBitPtr{ptr, (int)offs};
+  }
+  ConstBitPtr bits() const {
+    return ConstBitPtr{ptr, (int)offs};
+  }
+  BitPtr bits() {
+    return BitPtr{ptr, (int)offs};
+  }
+  BitString& reserve_bits(unsigned req_bits);
+  BitSliceWrite reserve_bitslice(unsigned req_bits);
+  BitString& append(const BitSlice& bs);
+  BitSlice subslice(unsigned from, unsigned bits) const;
+  BitSliceWrite subslice_write(unsigned from, unsigned bits);
+  std::string to_hex() const {
+    return bitstring::bits_to_hex(cbits(), size());
+  }
+  std::string to_binary() const {
+    return bitstring::bits_to_binary(cbits(), size());
+  }
+};
+
+extern std::ostream& operator<<(std::ostream& stream, const BitString& bs);
+extern std::ostream& operator<<(std::ostream& stream, Ref<BitString> bs_ref);
+
+extern template class Ref<BitString>;
+typedef Ref<BitString> BitStringRef;
+
+template <unsigned n>
+class BitArray {
+  static constexpr unsigned m = (n + 7) >> 3;
+  typedef std::array<unsigned char, m> byte_array_t;
+  typedef unsigned char raw_byte_array_t[m];
+  byte_array_t bytes;
+
+ public:
+  const unsigned char* data() const {
+    return bytes.data();
+  }
+  unsigned char* data() {
+    return bytes.data();
+  }
+  unsigned size() const {
+    return n;
+  }
+  const byte_array_t& as_array() const {
+    return bytes;
+  }
+  byte_array_t& as_array() {
+    return bytes;
+  }
+  Slice as_slice() const {
+    return Slice{data(), m};
+  }
+  MutableSlice as_slice() {
+    return MutableSlice{data(), m};
+  }
+  ConstBitPtr cbits() const {
+    return ConstBitPtr{data()};
+  }
+  ConstBitPtr bits() const {
+    return ConstBitPtr{data()};
+  }
+  BitPtr bits() {
+    return BitPtr{data()};
+  }
+  BitArray() = default;
+  BitArray(const BitArray&) = default;
+  BitArray(const byte_array_t& init_bytes) : bytes(init_bytes) {
+  }
+  explicit BitArray(const raw_byte_array_t init_bytes) {
+    std::memcpy(data(), init_bytes, m);
+  }
+  BitArray(ConstBitPtr from) {
+    bitstring::bits_memcpy(bits(), from, n);
+  }
+  template <int N = n, typename X = std::enable_if_t<N == n && N <= 64, int>>
+  explicit BitArray(long long val) {
+    bitstring::bits_store_long(bits(), val, n);
+  }
+  BitArray& operator=(const BitArray&) = default;
+  BitArray& operator=(const byte_array_t& set_bytes) {
+    bytes = set_bytes;
+    return *this;
+  }
+  BitArray& operator=(ConstBitPtr from) {
+    bitstring::bits_memcpy(bits(), from, n);
+    return *this;
+  }
+  BitArray& operator=(const raw_byte_array_t set_byte_array) {
+    std::memcpy(data(), set_byte_array, m);
+    return *this;
+  }
+  BitSliceWrite write_bitslice() {
+    return BitSliceWrite{data(), n};
+  }
+  BitSlice as_bitslice() const {
+    return BitSlice{data(), n};
+  }
+  //operator BitString() const {
+  //return BitString{as_bitslice()};
+  //}
+  Ref<BitString> make_bitstring_ref() const {
+    return td::make_ref<BitString>(as_bitslice());
+  }
+  unsigned long long to_ulong() const {
+    return bitstring::bits_load_ulong(bits(), n);
+  }
+  long long to_long() const {
+    return bitstring::bits_load_long(bits(), n);
+  }
+  void store_ulong(unsigned long long val) {
+    bitstring::bits_store_long(bits(), val, n);
+  }
+  void store_long(long long val) {
+    bitstring::bits_store_long(bits(), val, n);
+  }
+  void set_same(bool v) {
+    bytes.fill(static_cast<unsigned char>(v ? -1 : 0));
+  }
+  void set_zero() {
+    set_same(0);
+  }
+  void set_zero_s() {
+    volatile uint8* p = data();
+    auto x = m;
+    while (x--) {
+      *p++ = 0;
+    }
+  }
+  void set_ones() {
+    set_same(1);
+  }
+  void clear() {
+    set_zero();
+  }
+  bool is_zero() const {
+    return bitstring::bits_memscan(cbits(), n, 0) == n;
+  }
+  std::string to_hex() const {
+    return bitstring::bits_to_hex(cbits(), size());
+  }
+  std::string to_binary() const {
+    return bitstring::bits_to_binary(cbits(), size());
+  }
+  int compare(const BitArray& other) const {
+    return (n % 8 == 0) ? std::memcmp(data(), other.data(), n / 8) : bitstring::bits_memcmp(bits(), other.bits(), n);
+  }
+  bool operator==(const BitArray& other) const {
+    return (n % 8 == 0) ? (bytes == other.bytes) : !bitstring::bits_memcmp(bits(), other.bits(), n);
+  }
+  bool operator!=(const BitArray& other) const {
+    return (n % 8 == 0) ? (bytes != other.bytes) : bitstring::bits_memcmp(bits(), other.bits(), n);
+  }
+  bool operator<(const BitArray& other) const {
+    return (n % 8 == 0) ? (bytes < other.bytes) : (bitstring::bits_memcmp(bits(), other.bits(), n) < 0);
+  }
+  int compare(ConstBitPtr other) const {
+    return bitstring::bits_memcmp(bits(), other, n);
+  }
+  bool operator==(ConstBitPtr other) const {
+    return !compare(other);
+  }
+  bool operator!=(ConstBitPtr other) const {
+    return compare(other);
+  }
+  BitPtr::BitSelector operator[](int i) {
+    return bits()[i];
+  }
+  bool operator[](int i) const {
+    return cbits()[i];
+  }
+  void compute_sha256(BitPtr to) const {
+    bitstring::bits_sha256(to, cbits(), n);
+  }
+  void compute_sha256(BitArray<256>& to) const {
+    bitstring::bits_sha256(to.bits(), cbits(), n);
+  }
+  static inline BitArray zero() {
+    BitArray x;
+    x.set_zero();
+    return x;
+  }
+  static inline BitArray ones() {
+    BitArray x;
+    x.set_ones();
+    return x;
+  }
+  BitArray operator^(const BitArray& with) const {
+    BitArray res;
+    for (unsigned i = 0; i < m; i++) {
+      res.bytes[i] = bytes[i] ^ with.bytes[i];
+    }
+    return res;
+  }
+  unsigned scan(bool value) const {
+    return (unsigned)cbits().scan(value, n);
+  }
+  unsigned count_leading_zeroes() const {
+    return scan(false);
+  }
+  unsigned count_matching(ConstBitPtr other) const {
+    std::size_t cnt;
+    bitstring::bits_memcmp(cbits(), other, n, &cnt);
+    return (unsigned)cnt;
+  }
+  unsigned count_matching(const BitArray& other) const {
+    return count_matching(other.bits());
+  }
+};
+
+using Bits256 = BitArray<256>;
+using Bits128 = BitArray<128>;
+
+template <unsigned n>
+std::ostream& operator<<(std::ostream& stream, BitArray<n> bits) {
+  return stream << bits.to_hex();
+}
+
+template <unsigned N>
+Slice as_slice(const BitArray<N>& value) {
+  return value.as_slice();
+}
+
+template <unsigned N>
+MutableSlice as_slice(BitArray<N>& value) {
+  return value.as_slice();
+}
+
+template <unsigned N>
+Ref<BitString> make_bitstring_ref(const BitArray<N>& value) {
+  return value.make_bitstring_ref();
+}
+
+}  // namespace td