Remove dependency on fmt in favour of std::format

cpp-niel · cpp-niel · commit 0ff59adddfb0 · 2025-12-22T10:03:51.000+01:00
diff --git a/README.md b/README.md
@@ -68,8 +68,7 @@ Using [vcpkg](https://github.com/microsoft/vcpkg):
 Manual installation:
 
 - Install CMake 3.14 or higher.
-- For the library, install the following packages so that CMake's `find_package` can find them:
-    * [fmt](https://github.com/fmtlib/fmt)
+- The library itself has no third party dependencies. Earlier versions required [fmt](https://github.com/fmtlib/fmt).
 - For the tests, install the following packages so that CMake's `find_package` can find them:
     * [cairo](https://www.cairographics.org)
     * [doctest](https://github.com/onqtam/doctest)
@@ -141,7 +140,7 @@ the principles behind the layout of most formula elements.
 Many thanks to the authors and contributors of the following third party libraries, fonts,
 tools and services with which *mfl* is developed, built and tested:
 
-- [**fmt**](https://github.com/fmtlib/fmt) for text formatting
+- [**fmt**](https://github.com/fmtlib/fmt) for text formatting (used in earlier versions, but now no longer needed)
 - [**Clang**](https://clang.llvm.org) for compilation, standard library, static analysis, sanitizers and code formatting
 - [**GCC**](https://gcc.gnu.org) for compilation, standard library
 - [**CMake**](https://cmake.org) for build automation
diff --git a/include/mfl/detail/quantity.hpp b/include/mfl/detail/quantity.hpp
@@ -1,7 +1,6 @@
 #pragma once
 
-#include <fmt/format.h>
-
+#include <format>
 #include <iostream>
 
 namespace mfl::detail
@@ -41,33 +40,38 @@ namespace mfl::detail
         friend constexpr quantity operator+(const quantity x0, const quantity x1)
         {
             auto result = x0;
-            return result += x1;
+            result += x1;
+            return result;
         }
 
         friend constexpr quantity operator-(const quantity x0, const quantity x1)
         {
             auto result = x0;
-            return result -= x1;
+            result -= x1;
+            return result;
         }
 
         friend constexpr quantity operator-(const quantity x) { return quantity(-x.value()); }
 
         friend constexpr quantity operator*(const quantity x, const double scalar)
         {
             auto result = x;
-            return result *= scalar;
+            result *= scalar;
+            return result;
         }
 
         friend constexpr quantity operator*(const double scalar, const quantity x)
         {
             auto result = x;
-            return result *= scalar;
+            result *= scalar;
+            return result;
         }
 
         friend constexpr quantity operator/(const quantity x, const double scalar)
         {
             auto result = x;
-            return result /= scalar;
+            result /= scalar;
+            return result;
         }
 
         friend constexpr double operator/(const quantity x0, const quantity x1) { return x0.value_ / x1.value_; }
@@ -81,7 +85,5 @@ namespace mfl::detail
 
     template <typename Tag>
     std::ostream& operator<<(std::ostream& os, const quantity<Tag>& p)
-    {
-        return os << fmt::format("{}", p);
-    }
+    { return os << std::format("{}", p); }
 }
diff --git a/include/mfl/units.hpp b/include/mfl/units.hpp
@@ -2,9 +2,8 @@
 
 #include "mfl/detail/quantity.hpp"
 
-#include <fmt/core.h>
-
 #include <array>
+#include <format>
 
 namespace mfl
 {
@@ -36,18 +35,18 @@ namespace mfl
     template <typename Unit, char c0 = 0, char c1 = 0, char c2 = 0>
     struct unit_formatter
     {
-        constexpr auto parse(const fmt::format_parse_context& ctx) { return ctx.begin(); }
+        constexpr auto parse(const std::format_parse_context& ctx) { return ctx.begin(); }
 
         template <typename FormatContext>
         constexpr auto format(const Unit x, FormatContext& ctx) const
         {
             constexpr auto suffix = std::array{c0, c1, c2, '\0'};
-            return fmt::format_to(ctx.out(), "{}{}", x.value(), suffix.data());
+            return std::format_to(ctx.out(), "{}{}", x.value(), suffix.data());
         }
     };
 }
 
-namespace fmt
+namespace std
 {
     template <>
     struct [[maybe_unused]] formatter<mfl::inches> : mfl::unit_formatter<mfl::inches, '\"'>
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -1,6 +1,5 @@
-cmake_minimum_required (VERSION 3.14)
+cmake_minimum_required(VERSION 3.14)
 
-find_package(fmt REQUIRED)
 find_package(Threads)
 
 add_library(mfl
@@ -45,18 +44,17 @@ add_library(mfl
         parser/utf8.cpp
         settings.cpp
         units.cpp
-        )
+)
 
 target_include_directories(mfl PUBLIC
         $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
         $<INSTALL_INTERFACE:include>
-        )
+)
 target_include_directories(mfl PRIVATE ${PROJECT_SOURCE_DIR}/src)
 
 target_link_libraries(mfl
         PUBLIC
         mfl_options
         mfl_warnings
-        fmt::fmt
         ${CMAKE_THREAD_LIBS_INIT}
-        )
+)
diff --git a/src/parser/left_right.cpp b/src/parser/left_right.cpp
@@ -3,9 +3,8 @@
 #include "parser/parser_state.hpp"
 #include "parser/parser_utilities.hpp"
 
-#include <fmt/format.h>
-
 #include <algorithm>
+#include <format>
 #include <string>
 
 namespace mfl::parser
@@ -61,7 +60,7 @@ namespace mfl::parser
                 const auto full_name = ((tok == tokens::command) ? "\\"s : ""s) + name;
                 if (const auto type = get_delimiter_type(full_name); !is_valid_token or (type == delimiter_type::none))
                 {
-                    state.set_error(fmt::format("'{}' is not a valid delimiter.", full_name));
+                    state.set_error(std::format("'{}' is not a valid delimiter.", full_name));
                     return 0;
                 }
 
diff --git a/src/parser/parser_state.cpp b/src/parser/parser_state.cpp
@@ -1,6 +1,6 @@
 #include "parser/parser_state.hpp"
 
-#include <fmt/format.h>
+#include <format>
 
 namespace mfl::parser
 {
@@ -17,7 +17,7 @@ namespace mfl::parser
         if (lexer_token() == tokens::eof)
             set_error("unexpected end of input.");
         else if (lexer_token() != tok)
-            set_error(fmt::format("unexpected {} while expecting {}.", to_string(lexer_token()), to_string(tok)));
+            set_error(std::format("unexpected {} while expecting {}.", to_string(lexer_token()), to_string(tok)));
         else
             lexer_.move_to_next_token();
     }
@@ -43,7 +43,7 @@ namespace mfl::parser
 
     void parser_state::set_error(const std::string& error_text)
     {
-        error_ = fmt::format("Syntax error: {}", error_text);
+        error_ = std::format("Syntax error: {}", error_text);
 
         while (lexer_token() != tokens::eof)
             lexer_.move_to_next_token();
diff --git a/src/parser/parser_utilities.cpp b/src/parser/parser_utilities.cpp
@@ -5,11 +5,8 @@
 #include "parser/parser_state.hpp"
 #include "parser/script.hpp"
 
-#include <fmt/format.h>
-
 #include <algorithm>
-#include <charconv>
-#include <cstdlib>
+#include <format>
 
 namespace mfl::parser
 {
@@ -27,7 +24,7 @@ namespace mfl::parser
             }
 
             auto noads = create_script(state);
-            std::move(noads.begin(), noads.end(), std::back_inserter(result.noads));
+            std::ranges::move(noads, std::back_inserter(result.noads));
             tok = state.lexer_token();
         }
 
@@ -42,7 +39,7 @@ namespace mfl::parser
         {
             if (state.lexer_token() == tokens::eof)
             {
-                state.set_error(fmt::format("expected token not found: '{}'.", value));
+                state.set_error(std::format("expected token not found: '{}'.", value));
                 return {};
             }
 
@@ -114,17 +111,12 @@ namespace mfl::parser
 
         state.consume_token(tokens::close_brace);
 
-        char* str_end = nullptr;
-        const auto value = std::strtod(number_string.c_str(), &str_end);
-        // using the C function std::strtod until from_chars is available, so we have to do some pointer arithmetic
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-        if (str_end != number_string.data() + number_string.size())
-            state.set_error(fmt::format("'{}' does not represent a valid floating point value.", number_string));
-
-        // TODO - do this instead when from_chars becomes available ...
-        // const auto result = std::from_chars(number_string.data(), number_string.data() + number_string.size(),
-        // &value); if (result.ec == std::errc::invalid_argument)
-        //    state.set_error(fmt::format("'{}' does not represent a valid floating point value.", number_string));
+        double value = 0.0;
+        const auto [remaining, ec] =
+            std::from_chars(number_string.data(), number_string.data() + number_string.size(), value);
+
+        if ((ec == std::errc::invalid_argument) || !std::string(remaining).empty())
+            state.set_error(std::format("'{}' does not represent a valid floating point value.", number_string));
 
         return value;
     }
diff --git a/src/parser/scanner.hpp b/src/parser/scanner.hpp
@@ -1,9 +1,6 @@
 #pragma once
 
-#include <fmt/format.h>
-
 #include <concepts>
-#include <iostream>
 #include <istream>
 #include <string>
 
diff --git a/src/parser/unicode_index.cpp b/src/parser/unicode_index.cpp
@@ -13,9 +13,8 @@
 #include "parser/symbols/relational_operators.hpp"
 #include "parser/utf8.hpp"
 
-#include <fmt/format.h>
-
 #include <array>
+#include <format>
 #include <span>
 #include <tuple>
 #include <utility>
@@ -67,7 +66,7 @@ namespace mfl::parser
             if (const auto result = check(negations, tex_name)) return result;
             if (const auto result = check(additional_negations, tex_name)) return result;
 
-            state.set_error(fmt::format("Unknown symbol name '\\{}'.", tex_name));
+            state.set_error(std::format("Unknown symbol name '\\{}'.", tex_name));
             return 0;
         }
 
@@ -212,7 +211,7 @@ namespace mfl::parser
         const auto result = utf8::to_ucs4(name);
         if (!result)
         {
-            state.set_error(fmt::format("'{}' does not represent a valid utf8 character.", name));
+            state.set_error(std::format("'{}' does not represent a valid utf8 character.", name));
             return 0;
         }
 
diff --git a/tests/approval_tests/docs.cpp b/tests/approval_tests/docs.cpp
@@ -14,8 +14,8 @@
 #include "parser/symbols/relational_operators.hpp"
 
 #include <doctest/doctest.h>
-#include <fmt/format.h>
 
+#include <format>
 #include <ranges>
 
 namespace mfl
@@ -34,14 +34,15 @@ namespace mfl
 
         auto render_symbols(const symbol_render_config& config, const std::ranges::range auto& symbols)
         {
-            const auto d = std::div(long(std::ranges::distance(symbols)), long(config.num_columns));
-            const auto num_rows = size_t(d.quot + ((d.rem > 0) ? 1 : 0));
-            const auto width = 720_px;
-            const auto height = double(num_rows) * config.line_height + 40_px;
+            const auto num_symbols = static_cast<long>(std::ranges::distance(symbols));
+            const auto [quot, rem] = std::div(num_symbols, static_cast<long>(config.num_columns));
+            const auto num_rows = static_cast<size_t>(quot + ((rem > 0) ? 1 : 0));
+            constexpr auto width = 720_px;
+            const auto height = static_cast<double>(num_rows) * config.line_height + 40_px;
             auto columns = std::vector<column_config>(config.num_columns);
             for (auto&& [i, col] : std::views::enumerate(columns))
             {
-                col.x = (double(i) * (width / double(config.num_columns))) + 10_px;
+                col.x = (static_cast<double>(i) * (width / static_cast<double>(config.num_columns))) + 10_px;
                 col.line_height = config.line_height;
                 col.num_rows = num_rows;
             }
@@ -183,9 +184,10 @@ namespace mfl
 
     TEST_CASE("accents")
     {
-        const auto formulas = parser::accents     //
-                              | std::views::keys  //
-                              | std::views::transform([](const char* name) { return fmt::format("{}{{a}}", name); });
+        constexpr auto formulas =
+            parser::accents     //
+            | std::views::keys  //
+            | std::views::transform([](const char* name) { return std::format("{}{{a}}", name); });
         const auto result = render_symbols({.num_columns = 5}, formulas);
 
         approve_svg(result);
@@ -213,9 +215,10 @@ namespace mfl
     TEST_CASE("additional_accents")
     {
         // TODO - some additional accents are set in the wrong place
-        const auto formulas = parser::additional_accents  //
-                              | std::views::keys          //
-                              | std::views::transform([](const char* name) { return fmt::format("{}{{a}}", name); });
+        constexpr auto formulas =
+            parser::additional_accents  //
+            | std::views::keys          //
+            | std::views::transform([](const char* name) { return std::format("{}{{a}}", name); });
         const auto result = render_symbols({.num_columns = 3}, formulas);
 
         approve_svg(result);
@@ -310,10 +313,10 @@ namespace mfl
 
     TEST_CASE("delimiters")
     {
-        const auto formulas =
+        constexpr auto formulas =
             std::views::zip(parser::left_delimiters | std::views::keys, parser::right_delimiters | std::views::keys)
             | std::views::transform(
-                [](const auto delims) { return fmt::format("{} x \\{}", std::get<0>(delims), std::get<1>(delims)); });
+                [](const auto delims) { return std::format("{} x \\{}", std::get<0>(delims), std::get<1>(delims)); });
         const auto result = render_symbols({.num_columns = 2, .input_offset = 40_px}, formulas);
 
         approve_svg(result);
@@ -420,9 +423,9 @@ namespace mfl
 
     TEST_CASE("combining_symbols")
     {
-        const auto formulas = parser::combining_symbols  //
-                              | std::views::keys         //
-                              | std::views::transform([](const char* name) { return fmt::format("c \\{}", name); });
+        constexpr auto formulas = parser::combining_symbols  //
+                                  | std::views::keys         //
+                                  | std::views::transform([](const char* name) { return std::format("c \\{}", name); });
         const auto result = render_formulas({.width = 720_px,
                                              .height = 100_px,
                                              .render_input = true,
diff --git a/tests/fonts_for_tests/CMakeLists.txt b/tests/fonts_for_tests/CMakeLists.txt
diff --git a/tests/fonts_for_tests/src/freetype.cpp b/tests/fonts_for_tests/src/freetype.cpp
diff --git a/tests/unit_tests/parser/math_space.cpp b/tests/unit_tests/parser/math_space.cpp
diff --git a/tests/unit_tests/units.cpp b/tests/unit_tests/units.cpp
diff --git a/vcpkg.json b/vcpkg.json

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,6 @@`
`1`	`1`	`#pragma once`
`2`	`2`
`3`		`-#include <fmt/format.h>`
`4`		`-`
	`3`	`+#include <format>`
`5`	`4`	`#include <iostream>`
`6`	`5`
`7`	`6`	`namespace mfl::detail`
`@@ -41,33 +40,38 @@ namespace mfl::detail`
`41`	`40`	`friend constexpr quantity operator+(const quantity x0, const quantity x1)`
`42`	`41`	`{`
`43`	`42`	`auto result = x0;`
`44`		`- return result += x1;`
	`43`	`+ result += x1;`
	`44`	`+ return result;`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`friend constexpr quantity operator-(const quantity x0, const quantity x1)`
`48`	`48`	`{`
`49`	`49`	`auto result = x0;`
`50`		`- return result -= x1;`
	`50`	`+ result -= x1;`
	`51`	`+ return result;`
`51`	`52`	`}`
`52`	`53`
`53`	`54`	`friend constexpr quantity operator-(const quantity x) { return quantity(-x.value()); }`
`54`	`55`
`55`	`56`	`friend constexpr quantity operator*(const quantity x, const double scalar)`
`56`	`57`	`{`
`57`	`58`	`auto result = x;`
`58`		`- return result *= scalar;`
	`59`	`+ result *= scalar;`
	`60`	`+ return result;`
`59`	`61`	`}`
`60`	`62`
`61`	`63`	`friend constexpr quantity operator*(const double scalar, const quantity x)`
`62`	`64`	`{`
`63`	`65`	`auto result = x;`
`64`		`- return result *= scalar;`
	`66`	`+ result *= scalar;`
	`67`	`+ return result;`
`65`	`68`	`}`
`66`	`69`
`67`	`70`	`friend constexpr quantity operator/(const quantity x, const double scalar)`
`68`	`71`	`{`
`69`	`72`	`auto result = x;`
`70`		`- return result /= scalar;`
	`73`	`+ result /= scalar;`
	`74`	`+ return result;`
`71`	`75`	`}`
`72`	`76`
`73`	`77`	`friend constexpr double operator/(const quantity x0, const quantity x1) { return x0.value_ / x1.value_; }`
`@@ -81,7 +85,5 @@ namespace mfl::detail`
`81`	`85`
`82`	`86`	`template <typename Tag>`
`83`	`87`	`std::ostream& operator<<(std::ostream& os, const quantity<Tag>& p)`
`84`		`- {`
`85`		`- return os << fmt::format("{}", p);`
`86`		`- }`
	`88`	`+ { return os << std::format("{}", p); }`
`87`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,9 +2,8 @@`
`2`	`2`
`3`	`3`	`#include "mfl/detail/quantity.hpp"`
`4`	`4`
`5`		`-#include <fmt/core.h>`
`6`		`-`
`7`	`5`	`#include <array>`
	`6`	`+#include <format>`
`8`	`7`
`9`	`8`	`namespace mfl`
`10`	`9`	`{`
`@@ -36,18 +35,18 @@ namespace mfl`
`36`	`35`	`template <typename Unit, char c0 = 0, char c1 = 0, char c2 = 0>`
`37`	`36`	`struct unit_formatter`
`38`	`37`	`{`
`39`		`- constexpr auto parse(const fmt::format_parse_context& ctx) { return ctx.begin(); }`
	`38`	`+ constexpr auto parse(const std::format_parse_context& ctx) { return ctx.begin(); }`
`40`	`39`
`41`	`40`	`template <typename FormatContext>`
`42`	`41`	`constexpr auto format(const Unit x, FormatContext& ctx) const`
`43`	`42`	`{`
`44`	`43`	`constexpr auto suffix = std::array{c0, c1, c2, '\0'};`
`45`		`- return fmt::format_to(ctx.out(), "{}{}", x.value(), suffix.data());`
	`44`	`+ return std::format_to(ctx.out(), "{}{}", x.value(), suffix.data());`
`46`	`45`	`}`
`47`	`46`	`};`
`48`	`47`	`}`
`49`	`48`
`50`		`-namespace fmt`
	`49`	`+namespace std`
`51`	`50`	`{`
`52`	`51`	`template <>`
`53`	`52`	`struct [[maybe_unused]] formatter<mfl::inches> : mfl::unit_formatter<mfl::inches, '\"'>`