util: Use consteval checked format string in FatalErrorf, LogConnectFailure #30546

0assert(num_params == count); // The number of format arguments has to match the number of format specifiers in the string.

0util/string.h should add these lines:
1#include <assert.h>     // for assert

0./util/string.h:38:34: note: subexpression not valid in a constant expression
1   38 |         if (num_params != count) throw "Number of format specifiers and arguments must match";
2      |                                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3util/string.cpp:15:5: note: in call to 'CheckNumFormatSpecifiers({0, &""[0]})'
4   15 |     ConstevalFormatString<1>::CheckNumFormatSpecifiers("");
5      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

0FatalErrorf("%s%s: Failed to rewind index %s to a previous chain tip", __func__, GetName());

0FatalErrorf("%s%%: Failed to rewind index %s to a previous chain tip", __func__, GetName());
1FatalErrorf("%s, %s %d, %.2d:%.2d\n", 0, 0, 0, 0, 0);
2FatalErrorf("%1$s, %3$d. %2$s, %4$d:%5$.2d\n", 0, 0, 0, 0, 0);

 0constexpr static void CheckNumFormatSpecifiers(std::string_view str)
 1{
 2    int count{0};
 3    bool in_format{false};
 4    for (char c : str) {
 5        if (c == '%') in_format = !in_format;
 6        else if (in_format) {
 7            ++count;
 8            in_format = false;
 9        }
10    }
11    if (num_params != count) throw std::runtime_error("Format specifier count must match the argument count!");
12 }

 0constexpr static void CheckNumFormatSpecifiers(std::string_view str)
 1{
 2    int excess{num_params};
 3    bool in_format{false};
 4    for (char c : str) {
 5        if (c == '%') in_format = !in_format;
 6        else if (in_format) {
 7            --excess;
 8            in_format = false;
 9        }
10    }
11    if (excess) throw std::runtime_error("Format specifier count must match the argument count!");
12 }

0std::runtime_error("Format specifier count must match the argument count!")

0BOOST_CHECK_THROW(ConstevalFormatString<1>::CheckNumFormatSpecifiers(""), const char*);

0BOOST_CHECK_THROW(ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers(""), const char*);

 0constexpr static void Detail_CheckNumFormatSpecifiers(std::string_view str)
 1{
 2    int excess{num_params};
 3    bool in_format{false};
 4    for (char c: str) {
 5        if (c == '%') in_format = !in_format;
 6        else if (in_format) {
 7            --excess;
 8            in_format = false;
 9        }
10    }
11    if (in_format) throw "Format specifier incorrectly terminated by end of string!";
12    if (excess > 0) throw "Too few format specifiers!";
13    if (excess < 0) throw "Too many format specifiers!";
14}

0auto check_too_many_specifiers = [](ErrType str) { return str == "Too many format specifiers!"s; };
1BOOST_CHECK_EXCEPTION(ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers("%_"), ErrType, check_too_many_specifiers);
2
3auto check_too_few_specifiers = [](ErrType str) { return str == "Too few format specifiers!"s; };
4BOOST_CHECK_EXCEPTION(ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers(""), ErrType, check_too_few_specifiers);
5BOOST_CHECK_EXCEPTION(ConstevalFormatString<2>::Detail_CheckNumFormatSpecifiers("%_"), ErrType, check_too_few_specifiers);

0BOOST_AUTO_TEST_CASE(ConstevalFormatString_NumSpec)
1{
2    ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers("");
3    ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers("%");
4...
5    ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers("%_%%");
6    ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers("_%%%");

 0bitcoin/src/test/util_string_tests.cpp:16:19: error: static assertion expression is not an integral constant expression
 1    static_assert([] {
 2                  ^~~~
 3bitcoin/src/util/string.h:39:34: note: subexpression not valid in a constant expression
 4        if (num_params != count) throw "Format specifier count must match the argument count!";
 5                                 ^
 6bitcoin/src/test/util_string_tests.cpp:22:9: note: in call to 'Detail_CheckNumFormatSpecifiers({&"% % %_"[0], 6})'
 7        ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers("% % %_");
 8        ^
 9bitcoin/src/test/util_string_tests.cpp:16:19: note: in call to '&[] {
10    ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers("");
11    ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers("%%");
12    ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers("%_");
13    ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers("%%_");
14    ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers("_%%");
15    ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers("% % %_");
16    ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers("%_%%");
17    return true;
18}->operator()()'
19    static_assert([] {
20                  ^
211 error generated.
22make[2]: *** [src/test/CMakeFiles/test_bitcoin.dir/util_string_tests.cpp.o] Error 1
23make[1]: *** [src/test/CMakeFiles/test_bitcoin.dir/all] Error 2
24make: *** [all] Error 2

0unknown location:0: fatal error: in "util_string_tests/ConstevalFormatString_NumSpec": C string: Format specifier count must match the argument count!
1src/test/util_string_tests.cpp:13: last checkpoint: "ConstevalFormatString_NumSpec" test entry
2
3*** 1 failure is detected in the test module "Bitcoin Core Test Suite"

0    BOOST_CHECK_THROW(ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers(""), const char*);
1    BOOST_CHECK_THROW(ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers("%_"), const char*);
2    BOOST_CHECK_THROW(ConstevalFormatString<2>::Detail_CheckNumFormatSpecifiers("%_"), const char*);

0#include <string>
1using namespace std::string_literals;
2...
3    auto check_throw_num_spec = [](ErrType str) { return str == "Format specifier count must match the argument count!"s; };
4    BOOST_CHECK_EXCEPTION(ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers(""), ErrType, check_throw_num_spec);
5...

 0diff --git a/src/util/string.h b/src/util/string.h
 1--- a/src/util/string.h	(revision fa72ce66421d3f90a6794b3e54e56873ae81265f)
 2+++ b/src/util/string.h	(date 1725561949080)
 3@@ -18,13 +18,13 @@
 4 
 5 namespace util {
 6 /** Type to denote a format string that was checked at compile time */
 7-template <int num_params>
 8+template <size_t num_params>
 9 struct ConstevalFormatString {
10     const char* const fmt;
11     consteval ConstevalFormatString(const char* str) : fmt{str} { Detail_CheckNumFormatSpecifiers(fmt); }
12     constexpr static void Detail_CheckNumFormatSpecifiers(std::string_view str)
13     {
14-        int count{0};
15+        size_t count{0};
16         bool begin_f{false};
17         for (char c : str) {
18             bool perc{c == '%'};

0        if (count_nor && count_pos) throw "Format specifiers must be all positional or all non-positional!";

  0diff --git a/src/test/util_string_tests.cpp b/src/test/util_string_tests.cpp
  1index 1e041f37c6..43b63751d9 100644
  2--- a/src/test/util_string_tests.cpp
  3+++ b/src/test/util_string_tests.cpp
  4@@ -7,51 +7,58 @@
  5 #include <boost/test/unit_test.hpp>
  6 
  7 using namespace util;
  8+using namespace util::detail;
  9 
 10 BOOST_AUTO_TEST_SUITE(util_string_tests)
 11 
 12 BOOST_AUTO_TEST_CASE(ConstevalFormatString_NumSpec)
 13 {
 14-    // Compile-time sanity checks
 15-    static_assert([] {
 16-        ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers("");
 17-        ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers("%%");
 18-        ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers("%s");
 19-        ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers("%%s");
 20-        ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers("s%%");
 21-        ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers("%%%s");
 22-        ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers("%s%%");
 23-        ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers(" 1$s");
 24-        ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers("%1$s");
 25-        ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers("%1$s%1$s");
 26-        ConstevalFormatString<2>::Detail_CheckNumFormatSpecifiers("%2$s");
 27-        ConstevalFormatString<2>::Detail_CheckNumFormatSpecifiers("%2$s 4$s %2$s");
 28-        ConstevalFormatString<129>::Detail_CheckNumFormatSpecifiers("%129$s 999$s %2$s");
 29-        return true; // All checks above compiled and passed
 30-    }());
 31+    BOOST_CHECK_EQUAL(0, CountNumFormatSpecifiers(""));
 32+    BOOST_CHECK_EQUAL(0, CountNumFormatSpecifiers("%%"));
 33+    BOOST_CHECK_EQUAL(1, CountNumFormatSpecifiers("%s"));
 34+    BOOST_CHECK_EQUAL(0, CountNumFormatSpecifiers("%%s"));
 35+    BOOST_CHECK_EQUAL(0, CountNumFormatSpecifiers("s%%"));
 36+    BOOST_CHECK_EQUAL(1, CountNumFormatSpecifiers("%%%s"));
 37+    BOOST_CHECK_EQUAL(1, CountNumFormatSpecifiers("%s%%"));
 38+    BOOST_CHECK_EQUAL(0, CountNumFormatSpecifiers(" 1$s"));
 39+    BOOST_CHECK_EQUAL(1, CountNumFormatSpecifiers("%1$s"));
 40+    BOOST_CHECK_EQUAL(1, CountNumFormatSpecifiers("%1$s%1$s"));
 41+    BOOST_CHECK_EQUAL(2, CountNumFormatSpecifiers("%2$s"));
 42+    BOOST_CHECK_EQUAL(2, CountNumFormatSpecifiers("%2$s 4$s %2$s"));
 43+    BOOST_CHECK_EQUAL(129, CountNumFormatSpecifiers("%129$s 999$s %2$s"));
 44+
 45+    // existing "tests" in run-lint-format-strings.py parse_string_content
 46+    BOOST_CHECK_EQUAL(0, CountNumFormatSpecifiers("foo bar foo"));
 47+    BOOST_CHECK_EQUAL(1, CountNumFormatSpecifiers("foo %d bar foo"));
 48+    BOOST_CHECK_EQUAL(2, CountNumFormatSpecifiers("foo %d bar %i foo"));
 49+    BOOST_CHECK_EQUAL(2, CountNumFormatSpecifiers("foo %d bar %i foo %% foo"));
 50+    BOOST_CHECK_EQUAL(3, CountNumFormatSpecifiers("foo %d bar %i foo %% foo %d foo"));
 51+    // BOOST_CHECK_EQUAL(4, CountNumFormatSpecifiers("foo %d bar %i foo %% foo %*d foo"));
 52+    BOOST_CHECK_EQUAL(5, CountNumFormatSpecifiers("foo %5$d"));
 53+    // BOOST_CHECK_EQUAL(7, CountNumFormatSpecifiers("foo %5$*7$d"));
 54 
 55     // Negative checks at runtime
 56     using ErrType = const char*;
 57 
 58     auto check_mix{[](const ErrType& str) { return std::string_view{str} == "Format specifiers must be all positional or all non-positional!"; }};
 59-    BOOST_CHECK_EXCEPTION(ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers("%s%1$s"), ErrType, check_mix);
 60+    BOOST_CHECK_EXCEPTION(CountNumFormatSpecifiers("%s%1$s"), ErrType, check_mix);
 61 
 62     auto check_num_spec{[](const ErrType& str) { return std::string_view{str} == "Format specifier count must match the argument count!"; }};
 63-    BOOST_CHECK_EXCEPTION(ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers(""), ErrType, check_num_spec);
 64-    BOOST_CHECK_EXCEPTION(ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers("%s"), ErrType, check_num_spec);
 65-    BOOST_CHECK_EXCEPTION(ConstevalFormatString<2>::Detail_CheckNumFormatSpecifiers("%s"), ErrType, check_num_spec);
 66-    BOOST_CHECK_EXCEPTION(ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers("%1$s"), ErrType, check_num_spec);
 67-    BOOST_CHECK_EXCEPTION(ConstevalFormatString<2>::Detail_CheckNumFormatSpecifiers("%1$s"), ErrType, check_num_spec);
 68+    BOOST_CHECK_EXCEPTION(ConstevalFormatString<1>::CheckNumFormatSpecifiers(""), ErrType, check_num_spec);
 69+    BOOST_CHECK_EXCEPTION(ConstevalFormatString<0>::CheckNumFormatSpecifiers("%s"), ErrType, check_num_spec);
 70+    BOOST_CHECK_EXCEPTION(ConstevalFormatString<2>::CheckNumFormatSpecifiers("%s"), ErrType, check_num_spec);
 71+    BOOST_CHECK_EXCEPTION(ConstevalFormatString<0>::CheckNumFormatSpecifiers("%1$s"), ErrType, check_num_spec);
 72+    BOOST_CHECK_EXCEPTION(ConstevalFormatString<2>::CheckNumFormatSpecifiers("%1$s"), ErrType, check_num_spec);
 73 
 74     auto check_special{[](const ErrType& str) { return std::string_view{str} == "Invalid format specifier!"; }};
 75-    BOOST_CHECK_EXCEPTION(ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers("%_"), ErrType, check_special);
 76-    BOOST_CHECK_EXCEPTION(ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers("%\n"), ErrType, check_special);
 77+    BOOST_CHECK_EXCEPTION(CountNumFormatSpecifiers("%_"), ErrType, check_special);
 78+    BOOST_CHECK_EXCEPTION(CountNumFormatSpecifiers("%\n"), ErrType, check_special);
 79     // The "special" check also excludes "0", which would be out-of-range in tinyformat
 80-    BOOST_CHECK_EXCEPTION(ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers("%0$s"), ErrType, check_special);
 81+    BOOST_CHECK_EXCEPTION(CountNumFormatSpecifiers("%0$s"), ErrType, check_special);
 82 
 83     auto check_special_pos{[](const ErrType& str) { return std::string_view{str} == "Invalid positional format specifier!"; }};
 84-    BOOST_CHECK_EXCEPTION(ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers("%1$"), ErrType, check_special_pos);
 85-    BOOST_CHECK_EXCEPTION(ConstevalFormatString<0>::Detail_CheckNumFormatSpecifiers("%1$_"), ErrType, check_special_pos);
 86+    BOOST_CHECK_EXCEPTION(CountNumFormatSpecifiers("%1$"), ErrType, check_special_pos);
 87+    BOOST_CHECK_EXCEPTION(CountNumFormatSpecifiers("%1$_"), ErrType, check_special_pos);
 88 }
 89 
 90 BOOST_AUTO_TEST_SUITE_END()
 91diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
 92index 1624fb8b5b..ceb2e9ad54 100644
 93--- a/src/test/util_tests.cpp
 94+++ b/src/test/util_tests.cpp
 95@@ -154,18 +154,18 @@ BOOST_AUTO_TEST_CASE(parse_hex)
 96 
 97     // Basic test vector
 98     std::vector<unsigned char> expected(std::begin(HEX_PARSE_OUTPUT), std::end(HEX_PARSE_OUTPUT));
 99-    constexpr std::array<std::byte, 65> hex_literal_array{operator""_hex<util::detail::Hex(HEX_PARSE_INPUT)>()};
100+    constexpr std::array<std::byte, 65> hex_literal_array{operator""_hex<util::hex_literals::detail::Hex(HEX_PARSE_INPUT)>()};
101     auto hex_literal_span{MakeUCharSpan(hex_literal_array)};
102     BOOST_CHECK_EQUAL_COLLECTIONS(hex_literal_span.begin(), hex_literal_span.end(), expected.begin(), expected.end());
103 
104-    const std::vector<std::byte> hex_literal_vector{operator""_hex_v<util::detail::Hex(HEX_PARSE_INPUT)>()};
105+    const std::vector<std::byte> hex_literal_vector{operator""_hex_v<util::hex_literals::detail::Hex(HEX_PARSE_INPUT)>()};
106     hex_literal_span = MakeUCharSpan(hex_literal_vector);
107     BOOST_CHECK_EQUAL_COLLECTIONS(hex_literal_span.begin(), hex_literal_span.end(), expected.begin(), expected.end());
108 
109-    constexpr std::array<uint8_t, 65> hex_literal_array_uint8{operator""_hex_u8<util::detail::Hex(HEX_PARSE_INPUT)>()};
110+    constexpr std::array<uint8_t, 65> hex_literal_array_uint8{operator""_hex_u8<util::hex_literals::detail::Hex(HEX_PARSE_INPUT)>()};
111     BOOST_CHECK_EQUAL_COLLECTIONS(hex_literal_array_uint8.begin(), hex_literal_array_uint8.end(), expected.begin(), expected.end());
112 
113-    result = operator""_hex_v_u8<util::detail::Hex(HEX_PARSE_INPUT)>();
114+    result = operator""_hex_v_u8<util::hex_literals::detail::Hex(HEX_PARSE_INPUT)>();
115     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
116 
117     result = ParseHex(HEX_PARSE_INPUT);
118diff --git a/src/util/strencodings.h b/src/util/strencodings.h
119index 1543de03ab..0f145d91c5 100644
120--- a/src/util/strencodings.h
121+++ b/src/util/strencodings.h
122@@ -406,7 +406,7 @@ consteval uint8_t ConstevalHexDigit(const char c)
123  *   ParseHex() does is because heap-based containers cannot cross the compile-
124  *   time/runtime barrier.
125  */
126-inline namespace hex_literals {
127+namespace hex_literals {
128 namespace detail {
129 
130 template <size_t N>
131@@ -427,16 +427,16 @@ struct Hex {
132 
133 } // namespace detail
134 
135-template <util::detail::Hex str>
136+template <detail::Hex str>
137 constexpr auto operator""_hex() { return str.bytes; }
138 
139-template <util::detail::Hex str>
140+template <detail::Hex str>
141 constexpr auto operator""_hex_u8() { return std::bit_cast<std::array<uint8_t, str.bytes.size()>>(str.bytes); }
142 
143-template <util::detail::Hex str>
144+template <detail::Hex str>
145 constexpr auto operator""_hex_v() { return std::vector<std::byte>{str.bytes.begin(), str.bytes.end()}; }
146 
147-template <util::detail::Hex str>
148+template <detail::Hex str>
149 inline auto operator""_hex_v_u8() { return std::vector<uint8_t>{UCharCast(str.bytes.data()), UCharCast(str.bytes.data() + str.bytes.size())}; }
150 
151 } // inline namespace hex_literals
152diff --git a/src/util/string.h b/src/util/string.h
153index 754972b4ed..418dd92ca3 100644
154--- a/src/util/string.h
155+++ b/src/util/string.h
156@@ -18,50 +18,57 @@
157 #include <vector>
158 
159 namespace util {
160+namespace detail {
161+constexpr unsigned int CountNumFormatSpecifiers(std::string_view str) 
162+{
163+    unsigned count_nor{0}; // Number of "normal" specifiers, like %s
164+    unsigned count_pos{0}; // Max number in positional specifier, like %8$s
165+    bool begin_f{false};
166+    for (auto it{str.begin()}; it < str.end(); ++it) {
167+        bool perc{*it == '%'};
168+        if (begin_f) {
169+            // Almost any char is allowed by tinyformat to be used in a
170+            // format specifier, but a stricter check avoids bugs. For
171+            // instance, a strict check prevents consuming the newline
172+            // terminator in the format string "%\n". Also, excluding '0'
173+            // avoids an out-of-range position error in tinyformat for the
174+            // format string "%0$s\n".
175+            if (std::string_view{"123456789aAcdfeEfFgGinopsuxX%"}.find(*it) == std::string_view::npos) throw "Invalid format specifier!";
176+            auto it_num{it};
177+            unsigned maybe_num{0};
178+            while ('0' <= *it_num && *it_num <= '9') {
179+                maybe_num *= 10;
180+                maybe_num += *it_num - '0';
181+                ++it_num;
182+            };
183+            if (it_num == it) {
184+                // Non-positional specifier
185+                count_nor += !perc;
186+            } else {
187+                // Positional specifier
188+                if (*it_num != '$' || std::string_view{"aAcdfeEfFgGinopsuxX"}.find(*(++it_num)) == std::string_view::npos) {
189+                    throw "Invalid positional format specifier!";
190+                }
191+                count_pos = std::max(count_pos, maybe_num);
192+            }
193+            begin_f = false;
194+            continue;
195+        }
196+        if (perc) begin_f = true;
197+    }
198+    if (count_nor && count_pos) throw "Format specifiers must be all positional or all non-positional!";
199+    unsigned count{count_nor | count_pos};
200+    return count;
201+}
202+} // namespace detail
203 /** Type to denote a format string that was checked at compile time */
204 template <unsigned num_params>
205 struct ConstevalFormatString {
206     const char* const fmt;
207-    consteval ConstevalFormatString(const char* str) : fmt{str} { Detail_CheckNumFormatSpecifiers(fmt); }
208-    constexpr static void Detail_CheckNumFormatSpecifiers(std::string_view str)
209+    consteval ConstevalFormatString(const char* str) : fmt{str} { CheckNumFormatSpecifiers(str); }
210+    constexpr static void CheckNumFormatSpecifiers(std::string_view str)
211     {
212-        unsigned count_nor{0}; // Number of "normal" specifiers, like %s
213-        unsigned count_pos{0}; // Max number in positional specifier, like %8$s
214-        bool begin_f{false};
215-        for (auto it{str.begin()}; it < str.end(); ++it) {
216-            bool perc{*it == '%'};
217-            if (begin_f) {
218-                // Almost any char is allowed by tinyformat to be used in a
219-                // format specifier, but a stricter check avoids bugs. For
220-                // instance, a strict check prevents consuming the newline
221-                // terminator in the format string "%\n". Also, excluding '0'
222-                // avoids an out-of-range position error in tinyformat for the
223-                // format string "%0$s\n".
224-                if (std::string_view{"123456789aAcdfeEfFgGinopsuxX%"}.find(*it) == std::string_view::npos) throw "Invalid format specifier!";
225-                auto it_num{it};
226-                unsigned maybe_num{0};
227-                while ('0' <= *it_num && *it_num <= '9') {
228-                    maybe_num *= 10;
229-                    maybe_num += *it_num - '0';
230-                    ++it_num;
231-                };
232-                if (it_num == it) {
233-                    // Non-positional specifier
234-                    count_nor += !perc;
235-                } else {
236-                    // Positional specifier
237-                    if (*it_num != '$' || std::string_view{"aAcdfeEfFgGinopsuxX"}.find(*(++it_num)) == std::string_view::npos) {
238-                        throw "Invalid positional format specifier!";
239-                    }
240-                    count_pos = std::max(count_pos, maybe_num);
241-                }
242-                begin_f = false;
243-                continue;
244-            }
245-            if (perc) begin_f = true;
246-        }
247-        if (count_nor && count_pos) throw "Format specifiers must be all positional or all non-positional!";
248-        unsigned count{count_nor | count_pos};
249+        unsigned count{detail::CountNumFormatSpecifiers(str)};
250         if (num_params != count) throw "Format specifier count must match the argument count!";
251     }
252 };

0        unsigned count_normal{0}; // Number of "normal" specifiers, like %s

0    auto check_mix{[](const ErrType& str) { return str == std::string_view{"Format specifiers must be all positional or all non-positional!"}; }};

0        ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers("%02d");

0src/netbase.cpp:            LogError("Proxy requested wrong authentication method %02x\n", pchRet1[1]);
1src/flatfile.cpp:                LogDebug(BCLog::VALIDATION, "Pre-allocating up to position 0x%x in %s%05u.dat\n", new_size, m_prefix, pos.nFile);
2src/init.cpp:                LogPrintf(" block index %15dms\n", Ticks<std::chrono::milliseconds>(SteadyClock::now() - load_block_index_start_time));
3src/node/blockstorage.cpp:            LogDebug(BCLog::BLOCKSTORAGE, "Prune: %s deleted blk/rev (%05u)\n", __func__, *it);
4src/node/blockstorage.cpp:                          "Failed to flush previous block file %05i (finalize=1, finalize_undo=%i) before opening new block file %05i\n",
5src/node/blockstorage.cpp:                LogPrintLevel(BCLog::BLOCKSTORAGE, BCLog::Level::Warning, "Failed to flush undo file %05i\n", _pos.nFile);
6src/node/blockstorage.cpp:            LogPrintf("Reindexing block file blk%05u.dat...\n", (unsigned int)nFile);

0        // The current implementation ignores `*` dynamic width/precision
1        // arguments to minimize code complexity, but this behaviour does
2        // not need to be preserved.
3        ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers("%*c");
4        ConstevalFormatString<2>::Detail_CheckNumFormatSpecifiers("%2$*3$d");
5        ConstevalFormatString<1>::Detail_CheckNumFormatSpecifiers("%.*f");

 0            unsigned maybe_num{0};
 1            while ('0' <= *it && *it <= '9') {
 2                maybe_num *= 10;
 3                maybe_num += *it - '0';
 4                ++it;
 5            };
 6
 7            if (*it == '$') {
 8                // Positional specifier
 9                if (maybe_num == 0) throw "Positional format specifier must indicate at least 1";
10                count_pos = std::max(count_pos, maybe_num);

0                if (maybe_num == 0) throw "Positional format specifier must have position of at least 1";

0                if (maybe_num == 0) throw "Positional format specifiers start at 1"};

 0const std::string error = strprintf(
 1    "Data directory %1$s contains a %2$s file which is ignored, because a different configuration file "
 2    "%3$s from %4$s is being used instead. Possible ways to address this would be to:\n"
 3    "- Delete or rename the %2$s file in data directory %1$s.\n"
 4    "- Change datadir= or conf= options to specify one configuration file, not two, and use "
 5    "includeconf= to include any other configuration files.\n"
 6    "- Set allowignoredconf=1 option to treat this condition as a warning, not an error.",
 7    fs::quoted(fs::PathToString(base_path)),
 8    fs::quoted(BITCOIN_CONF_FILENAME),
 9    fs::quoted(fs::PathToString(orig_config_path)),
10    config_source);

 0const std::string base_path_str = fs::quoted(fs::PathToString(base_path));
 1const std::string config_file_name = fs::quoted(BITCOIN_CONF_FILENAME);
 2const std::string orig_config_path_str = fs::quoted(fs::PathToString(orig_config_path));
 3const std::string error = strprintf(
 4    "Data directory %s contains a %s file which is ignored, because a different configuration file "
 5    "%s from %s is being used instead. Possible ways to address this would be to:\n"
 6    "- Delete or rename the %s file in data directory %s.\n"
 7    "- Change datadir= or conf= options to specify one configuration file, not two, and use "
 8    "includeconf= to include any other configuration files.\n"
 9    "- Set allowignoredconf=1 option to treat this condition as a warning, not an error.",
10    base_path_str,
11    config_file_name,
12    orig_config_path_str,
13    config_source,
14    config_file_name,
15    base_path_str
16);

 0/**
 1 * [@brief](/bitcoin-bitcoin/contributor/brief/) A wrapper for a compile-time partially validated format string
 2 *
 3 * This struct can be used to enforce partial compile-time validation of format strings, to reduce
 4 * the likelihood of tinyformat throwing exceptions at run-time. Validation is partial to try and
 5 * prevent the most common errors while avoiding re-implementing the entire parsing logic.
 6 * 
 7 * [@note](/bitcoin-bitcoin/contributor/note/) Counting of `*` dynamic width and precision fields (such as `%*c`, `%2$*3$d`, `%.*f`) is
 8 * notably not implemented to minimize code complexity as long they are not used in the codebase.
 9 * Usage of these fields is not counted and can lead to run-time exceptions.
10 */

 0constexpr static void Detail_CheckNumFormatSpecifiers(std::string_view str)
 1{
 2    unsigned count{0};
 3    unsigned maybe_num{0};
 4    bool inside_format_specifier = false;
 5    bool has_normal = false, has_positional = false;
 6    for (auto it = str.begin(); it < str.end(); ++it) {
 7        if (*it == '%') inside_format_specifier = !inside_format_specifier;
 8        else if (inside_format_specifier) {
 9            if (std::isdigit(*it)) maybe_num = maybe_num * 10 + (*it - '0');
10            else if (*it == '$') {
11                if (maybe_num == 0) throw "Positional format specifier must be at least 1";
12                count = std::max(count, maybe_num);
13                has_positional = true;
14                inside_format_specifier = false;
15            } else {
16                ++count;
17                maybe_num = 0;
18                has_normal = true;
19                inside_format_specifier = false;
20            }
21        } else maybe_num = 0;
22    }
23
24    if (has_normal && has_positional) throw "Format specifiers must be all positional or all non-positional!";
25    if (inside_format_specifier || maybe_num > 0) throw "Format specifier incorrectly terminated by end of string";
26    if (num_params != count) throw "Format specifier count must match the argument count!";
27}

0src/util/string.h:47:17: note: non-constexpr function 'isdigit' cannot be used in a constant expression
1   47 |             if (std::isdigit(*it)) maybe_num = maybe_num * 10 + (*it - '0');
2      |                 ^

 0constexpr static void Detail_CheckNumFormatSpecifiers(std::string_view str)
 1{
 2    unsigned count{0};
 3    unsigned maybe_num{0};
 4    bool inside_format = false;
 5    bool has_normal = false, has_positional = false;
 6    for (char c : str) {
 7        if (c == '%') {
 8            inside_format = !inside_format;
 9        } else if (inside_format) {
10            if ('0' <= c && c <= '9') {
11                maybe_num = maybe_num * 10 + (c - '0');
12            } else if (c == '$') {
13                if (maybe_num == 0) throw "Positional format specifier must have position of at least 1";
14                count = std::max(count, maybe_num);
15                has_positional = true;
16                inside_format = false;
17            } else {
18                ++count;
19                maybe_num = 0;
20                has_normal = true;
21                inside_format = false;
22            }
23        } else
24            maybe_num = 0;
25    }
26    if (has_normal && has_positional) throw "Format specifiers must be all positional or all non-positional!";
27    if (inside_format || maybe_num > 0) throw "Format specifier incorrectly terminated by end of string";
28    if (num_params != count) throw "Format specifier count must match the argument count!";
29}