update

Author: Mr-Leshiy

include/veriblock/pop/blockchain/blockchain_util.hpp

@@ -68,7 +68,7 @@ bool recoverEndorsements(ProtectedBlockTree& ed_,
     }
 
     auto* endorsed = ed_.getBlockIndex(e.endorsedHash);
-    if (!endorsed) {
+    if (endorsed == nullptr) {
       return state.Invalid(
           "no-endorsed",
           format("Can not find endorsed block in {}", e.toPrettyString()));
@@ -89,7 +89,7 @@ bool recoverEndorsements(ProtectedBlockTree& ed_,
     }
 
     auto* blockOfProof = as_mut(ing).getBlockIndex(e.blockOfProof);
-    if (!blockOfProof) {
+    if (blockOfProof == nullptr) {
       return state.Invalid(
           "bad-blockofproof",
           format("Block Of Proof {} does not exist in SP chain",
@@ -107,8 +107,8 @@ bool recoverEndorsements(ProtectedBlockTree& ed_,
                      "same endorsement is added to endorsedBy second time");
       bool isDirty = endorsed->isDirty();
       endorsed->insertEndorsedBy(endorsement);
-      // keep dirty flag since recoverEndorsements is used when loading blocks from storage
-      // and should not affect dirtyness of the blocks
+      // keep dirty flag since recoverEndorsements is used when loading blocks
+      // from storage and should not affect dirtyness of the blocks
       if (!isDirty) {
         endorsed->unsetDirty();
       }

include/veriblock/pop/blockchain/chain.hpp

@@ -151,7 +151,7 @@ typename C::index_t* findFork(const C& chain,
   if (pindex->getHeight() > lastHeight) {
     pindex = pindex->getAncestor(lastHeight);
   }
-  while (pindex && !chain.contains(pindex)) {
+  while (pindex != nullptr && !chain.contains(pindex)) {
     pindex = pindex->getPrev();
   }
   return const_cast<typename C::index_t*>(pindex);
@@ -164,7 +164,7 @@ const index_t* findBlockContainingEndorsement(
     const index_t* workBlock,
     const typename index_t::endorsement_t::id_t& id,
     const uint32_t& window) {
-  for (uint32_t count = 0; count < window && workBlock &&
+  for (uint32_t count = 0; count < window && workBlock != nullptr &&
                            workBlock->getHeight() >= chain.getStartHeight();
        count++) {
     if (workBlock->getContainingEndorsements().count(id)) {

include/veriblock/pop/blockchain/commands/addendorsement.hpp

@@ -36,15 +36,15 @@ struct AddEndorsement : public Command {
 
   bool Execute(ValidationState& state) noexcept override {
     auto* containing = ed_->getBlockIndex(e_->containingHash);
-    if (!containing) {
+    if (containing == nullptr) {
       return state.Invalid(
           protected_block_t::name() + "-no-containing",
           format("Can not find containing block in endorsement={}",
                  e_->toPrettyString()));
     }
 
     auto* endorsed = ed_->getBlockIndex(e_->endorsedHash);
-    if (!endorsed) {
+    if (endorsed == nullptr) {
       return state.Invalid(protected_block_t::name() + "-no-endorsed-block",
                            format("Endorsed block={} not found in the tree",
                                   HexStr(e_->endorsedHash)));
@@ -67,7 +67,7 @@ struct AddEndorsement : public Command {
     }
 
     auto* blockOfProof = ing_->getBlockIndex(e_->blockOfProof);
-    if (!blockOfProof) {
+    if (blockOfProof == nullptr) {
       return state.Invalid(
           protected_block_t::name() + "-block-of-proof-not-found",
           format("Can not find block of proof in SP Chain ({})",

include/veriblock/pop/third_party/fmt/core.h

@@ -1203,7 +1203,7 @@ template <typename Context> struct arg_mapper {
     // a pointer cast it to "void *" or "const void *". In particular, this
     // forbids formatting of "[const] volatile char *" which is printed as bool
     // by iostreams.
-    static_assert(!sizeof(T), "formatting of non-void pointers is disallowed");
+    static_assert(sizeof(T) != 0, "formatting of non-void pointers is disallowed");
     return 0;
   }
 

include/veriblock/pop/third_party/fmt/format-inl.h

@@ -2362,7 +2362,7 @@ void fallback_format(Double d, int num_digits, bool binary32, buffer<char>& buf,
   // Invariant: value == (numerator / denominator) * pow(10, exp10).
   if (num_digits < 0) {
     // Generate the shortest representation.
-    if (!upper) upper = &lower;
+    if (upper == nullptr) upper = &lower;
     bool even = (value.f & 1) == 0;
     num_digits = 0;
     char* data = buf.data();

include/veriblock/pop/third_party/fmt/format.h

@@ -808,7 +808,7 @@ FMT_CONSTEXPR bool is_supported_floating_point(T) {
 // represent all values of an integral type T.
 template <typename T>
 using uint32_or_64_or_128_t =
-    conditional_t<num_bits<T>() <= 32 && !FMT_REDUCE_INT_INSTANTIATIONS,
+    conditional_t<num_bits<T>() <= 32 && FMT_REDUCE_INT_INSTANTIATIONS == 0,
                   uint32_t,
                   conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>>;
 
@@ -1411,8 +1411,8 @@ FMT_CONSTEXPR float_specs parse_float_type_spec(
 template <typename Char, typename Handler>
 FMT_CONSTEXPR void handle_char_specs(const basic_format_specs<Char>* specs,
                                      Handler&& handler) {
-  if (!specs) return handler.on_char();
-  if (specs->type && specs->type != 'c') return handler.on_int();
+  if (specs == nullptr) return handler.on_char();
+  if (specs->type != 0 && specs->type != 'c') return handler.on_int();
   if (specs->align == align::numeric || specs->sign != sign::none || specs->alt)
     handler.on_error("invalid format specifier for char");
   handler.on_char();
@@ -1665,7 +1665,7 @@ template <typename OutputIt, typename Char, typename UInt> struct int_writer {
     std::string groups = grouping<Char>(locale);
     if (groups.empty()) return on_dec();
     auto sep = thousands_sep<Char>(locale);
-    if (!sep) return on_dec();
+    if (sep == 0) return on_dec();
     int num_digits = count_digits(abs_value);
     int size = num_digits, n = num_digits;
     std::string::const_iterator group = groups.cbegin();
@@ -1762,7 +1762,7 @@ template <typename Char, typename UInt,
 inline Char* write_significand(Char* out, UInt significand,
                                int significand_size, int integral_size,
                                Char decimal_point) {
-  if (!decimal_point)
+  if (decimal_point == 0)
     return format_decimal(out, significand, significand_size).end;
   auto end = format_decimal(out + 1, significand, significand_size).end;
   if (integral_size == 1)
@@ -1790,7 +1790,7 @@ inline OutputIt write_significand(OutputIt out, const char* significand,
                                   int significand_size, int integral_size,
                                   Char decimal_point) {
   out = detail::copy_str<Char>(significand, significand + integral_size, out);
-  if (!decimal_point) return out;
+  if (decimal_point == 0) return out;
   *out++ = decimal_point;
   return detail::copy_str<Char>(significand + integral_size,
                                 significand + significand_size, out);
@@ -1910,7 +1910,7 @@ OutputIt write(OutputIt out, T value, basic_format_specs<Char> specs,
   if (!std::isfinite(value))
     return write_nonfinite(out, std::isinf(value), specs, fspecs);
 
-  if (specs.align == align::numeric && fspecs.sign) {
+  if (specs.align == align::numeric && fspecs.sign != 0) {
     auto it = reserve(out, 1);
     *it++ = static_cast<Char>(data::signs[fspecs.sign]);
     out = base_iterator(out, it);
@@ -1924,7 +1924,7 @@ OutputIt write(OutputIt out, T value, basic_format_specs<Char> specs,
     snprintf_float(promote_float(value), specs.precision, fspecs, buffer);
     return write_bytes(out, {buffer.data(), buffer.size()}, specs);
   }
-  int precision = specs.precision >= 0 || !specs.type ? specs.precision : 6;
+  int precision = specs.precision >= 0 || specs.type == 0 ? specs.precision : 6;
   if (fspecs.format == float_format::exp) {
     if (precision == max_value<int>())
       FMT_THROW(format_error("number is too big"));
@@ -2066,7 +2066,7 @@ OutputIt write(OutputIt out, Char value) {
 
 template <typename Char, typename OutputIt>
 OutputIt write(OutputIt out, const Char* value) {
-  if (!value) {
+  if (value == nullptr) {
     FMT_THROW(format_error("string pointer is null"));
   } else {
     auto length = std::char_traits<Char>::length(value);
@@ -2225,7 +2225,7 @@ class arg_formatter_base {
   }
 
   void write(const Char* value) {
-    if (!value) {
+    if (value == nullptr) {
       FMT_THROW(format_error("string pointer is null"));
     } else {
       auto length = std::char_traits<char_type>::length(value);
@@ -2259,7 +2259,7 @@ class arg_formatter_base {
   }
 
   iterator operator()(bool value) {
-    if (specs_ && specs_->type) return (*this)(value ? 1 : 0);
+    if (specs_ != nullptr && specs_->type != 0) return (*this)(value ? 1 : 0);
     write(value != 0);
     return out_;
   }
@@ -2275,7 +2275,7 @@ class arg_formatter_base {
   }
 
   iterator operator()(const Char* value) {
-    if (!specs_) return write(value), out_;
+    if (specs_ == nullptr) return write(value), out_;
     handle_cstring_type_spec(specs_->type, cstring_spec_handler(*this, value));
     return out_;
   }
@@ -2773,7 +2773,7 @@ FMT_CONSTEXPR int code_point_length(const Char* begin) {
   // Compute the pointer to the next character early so that the next
   // iteration can start working on the next character. Neither Clang
   // nor GCC figure out this reordering on their own.
-  return len + !len;
+  return len + (int)(len == 0);
 }
 
 template <typename Char> constexpr bool is_ascii_letter(Char c) {

include/veriblock/pop/third_party/fmt/printf.h

@@ -251,7 +251,7 @@ class printf_arg_formatter : public detail::arg_formatter_base<OutputIt, Char> {
       this->write(value != 0);
     } else if (std::is_same<T, char_type>::value) {
       format_specs& fmt_specs = *this->specs();
-      if (fmt_specs.type && fmt_specs.type != 'c')
+      if (fmt_specs.type != 0 && fmt_specs.type != 'c')
         return (*this)(static_cast<int>(value));
       fmt_specs.sign = sign::none;
       fmt_specs.alt = false;

include/veriblock/pop/third_party/thread_pool/fixed_function.hpp

@@ -109,7 +109,7 @@ class FixedFunction<R(ARGS...), STORAGE_SIZE>
      */
     R operator()(ARGS... args)
     {
-        if(!m_method_ptr) throw std::runtime_error("call of empty functor");
+        if(m_method_ptr == nullptr) throw std::runtime_error("call of empty functor");
         return m_method_ptr(&m_storage, m_function_ptr, args...);
     }
 

src/pop/third_party/secp256k1/ecdsa_impl.hpp

@@ -141,7 +141,7 @@ static int secp256k1_der_parse_integer(secp256k1_scalar *r, const unsigned char
     if (rlen > 32) {
         overflow = 1;
     }
-    if (!overflow) {
+    if (overflow == 0) {
         memcpy(ra + 32 - rlen, *sig, rlen);
         secp256k1_scalar_set_b32(r, ra, &overflow);
     }
@@ -167,10 +167,10 @@ static int secp256k1_ecdsa_sig_parse(secp256k1_scalar *rr, secp256k1_scalar *rs,
         return 0;
     }
 
-    if (!secp256k1_der_parse_integer(rr, &sig, sigend)) {
+    if (secp256k1_der_parse_integer(rr, &sig, sigend) == 0) {
         return 0;
     }
-    if (!secp256k1_der_parse_integer(rs, &sig, sigend)) {
+    if (secp256k1_der_parse_integer(rs, &sig, sigend) == 0) {
         return 0;
     }
 
@@ -215,7 +215,7 @@ static int secp256k1_ecdsa_sig_verify(const secp256k1_ecmult_context *ctx, const
     secp256k1_gej pubkeyj;
     secp256k1_gej pr;
 
-    if (secp256k1_scalar_is_zero(sigr) || secp256k1_scalar_is_zero(sigs)) {
+    if (secp256k1_scalar_is_zero(sigr) != 0 || secp256k1_scalar_is_zero(sigs) != 0) {
         return 0;
     }
 

src/pop/third_party/secp256k1/eckey_impl.hpp

@@ -19,10 +19,10 @@ namespace altintegration {
 static int secp256k1_eckey_pubkey_parse(secp256k1_ge *elem, const unsigned char *pub, size_t size) {
     if (size == 33 && (pub[0] == SECP256K1_TAG_PUBKEY_EVEN || pub[0] == SECP256K1_TAG_PUBKEY_ODD)) {
         secp256k1_fe x;
-        return secp256k1_fe_set_b32(&x, pub+1) && secp256k1_ge_set_xo_var(elem, &x, pub[0] == SECP256K1_TAG_PUBKEY_ODD);
+        return secp256k1_fe_set_b32(&x, pub+1) != 0 && secp256k1_ge_set_xo_var(elem, &x, pub[0] == SECP256K1_TAG_PUBKEY_ODD);
     } else if (size == 65 && (pub[0] == SECP256K1_TAG_PUBKEY_UNCOMPRESSED || pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_EVEN || pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_ODD)) {
         secp256k1_fe x, y;
-        if (!secp256k1_fe_set_b32(&x, pub+1) || !secp256k1_fe_set_b32(&y, pub+33)) {
+        if (secp256k1_fe_set_b32(&x, pub+1) == 0 || secp256k1_fe_set_b32(&y, pub+33) == 0) {
             return 0;
         }
         secp256k1_ge_set_xy(elem, &x, &y);