Complete migration to fmt 7.0

src/dds/build/builder.cpp

 
     dds::stopwatch sw;
     plan.compile_all(env, params.parallel_jobs);
-    log::info("Compilation completed in {:n}ms", sw.elapsed_ms().count());
+    log::info("Compilation completed in {:L}ms", sw.elapsed_ms().count());
 
     sw.reset();
     plan.archive_all(env, params.parallel_jobs);
-    log::info("Archiving completed in {:n}ms", sw.elapsed_ms().count());
+    log::info("Archiving completed in {:L}ms", sw.elapsed_ms().count());
 
     sw.reset();
     plan.link_all(env, params.parallel_jobs);
-    log::info("Runtime binary linking completed in {:n}ms", sw.elapsed_ms().count());
+    log::info("Runtime binary linking completed in {:L}ms", sw.elapsed_ms().count());
 
     sw.reset();
     auto test_failures = plan.run_all_tests(env, params.parallel_jobs);
-    log::info("Test execution finished in {:n}ms", sw.elapsed_ms().count());
+    log::info("Test execution finished in {:L}ms", sw.elapsed_ms().count());
 
     for (auto& fail : test_failures) {
         log_failure(fail);

src/dds/build/plan/archive.cpp

     // Do it!
     log::info("[{}] Archive: {}", _qual_name, out_relpath);
     auto&& [dur_ms, ar_res] = timed<std::chrono::milliseconds>([&] { return run_proc(ar_cmd); });
-    log::info("[{}] Archive: {} - {:n}ms", _qual_name, out_relpath, dur_ms.count());
+    log::info("[{}] Archive: {} - {:L}ms", _qual_name, out_relpath, dur_ms.count());
 
     // Check, log, and throw
     if (!ar_res.okay()) {

src/dds/build/plan/compile_exec.cpp

     auto&& [dur_ms, proc_res]
         = timed<std::chrono::milliseconds>([&] { return run_proc(cf.cmd_info.command); });
     auto nth = counter.n.fetch_add(1);
-    log::info("{:60} - {:>7n}ms [{:{}}/{}]",
+    log::info("{:60} - {:>7L}ms [{:{}}/{}]",
               msg,
               dur_ms.count(),
               nth,

src/dds/build/plan/exe.cpp

     log::info(msg);
     auto [dur_ms, proc_res]
         = timed<std::chrono::milliseconds>([&] { return run_proc(link_command); });
-    log::info("{} - {:>6n}ms", msg, dur_ms.count());
+    log::info("{} - {:>6L}ms", msg, dur_ms.count());
 
     // Check and throw if errant
     if (!proc_res.okay()) {
         [&] { return run_proc({.command = {exe_path.string()}, .timeout = 10s}); });
 
     if (res.okay()) {
-        log::info("{} - PASSED - {:>9n}μs", msg, dur.count());
+        log::info("{} - PASSED - {:>9L}μs", msg, dur.count());
         return std::nullopt;
     } else {
         auto exit_msg = fmt::format(res.signal ? "signalled {}" : "exited {}",
                                     res.signal ? res.signal : res.retc);
         auto fail_str = res.timed_out ? "TIMEOUT" : "FAILED ";
-        log::error("{} - {} - {:>9n}μs [{}]", msg, fail_str, dur.count(), exit_msg);
+        log::error("{} - {} - {:>9L}μs [{}]", msg, fail_str, dur.count(), exit_msg);
         test_failure f;
         f.executable_path = exe_path;
         f.output          = res.output;

src/dds/catalog/import.cpp

 
 #include <dds/error/errors.hpp>
 
+#include <fmt/core.h>
 #include <json5/parse_data.hpp>
 #include <neo/assert.hpp>
 #include <semester/walk.hpp>
-#include <spdlog/fmt/fmt.h>
 
 #include <optional>
 
 };
 
 template <typename KF, typename... Args>
-any_key(KF&&, Args&&...) -> any_key<KF, Args...>;
+any_key(KF&&, Args&&...)->any_key<KF, Args...>;
 
 namespace {
 

src/dds/deps.cpp

 #include <json5/parse_data.hpp>
 #include <semester/walk.hpp>
 
-#include <spdlog/fmt/fmt.h>
+#include <fmt/core.h>
 
 #include <cctype>
 #include <sstream>

src/dds/error/errors.hpp

 #pragma once
 
-#include <spdlog/fmt/fmt.h>
+#include <fmt/core.h>
 
 #include <stdexcept>
 #include <string_view>

src/dds/package/id.cpp

 
 #include <dds/error/errors.hpp>
 
-#include <spdlog/fmt/fmt.h>
+#include <fmt/core.h>
 
 #include <tuple>
 

src/dds/toolchain/from_json.cpp

 #include <dds/util/algo.hpp>
 #include <dds/util/shlex.hpp>
 
+#include <fmt/core.h>
 #include <json5/parse_data.hpp>
 #include <semester/decomp.hpp>
-#include <spdlog/fmt/fmt.h>
 
 #include <string>
 

src/dds/usage_reqs.cpp

 #include <dds/error/errors.hpp>
 #include <dds/util/algo.hpp>
 
-#include <spdlog/fmt/fmt.h>
+#include <fmt/core.h>
 
 #include <stdexcept>
 

src/dds/util/flock.nix.cpp

 
 #include <dds/util/signal.hpp>
 
-#include <spdlog/fmt/fmt.h>
+#include <fmt/core.h>
 
 #include <fcntl.h>
 #include <sys/file.h>

src/dds/util/flock.win.cpp

 
 #include <dds/util/signal.hpp>
 
-#include <spdlog/fmt/fmt.h>
+#include <fmt/core.h>
 #include <wil/resource.h>
 
+#include <cassert>
+
 using namespace dds;
 
 namespace {

src/dds/util/fs.cpp

 #include "./fs.hpp"
 
-#include <spdlog/fmt/fmt.h>
+#include <fmt/core.h>
 
 #include <sstream>
 

src/dds/util/log.hpp

 };
 
 template <formattable... Args>
-void log(level l, std::string_view s, const Args&... args) {
+void log(level l, std::string_view s, const Args&... args) noexcept {
     if (int(l) >= int(current_log_level)) {
         auto message = fmt::format(s, args...);
         log_print(l, message);

src/libman/index.cpp

 
 #include <libman/parse.hpp>
 
-#include <spdlog/fmt/fmt.h>
+#include <fmt/core.h>
 
 using namespace lm;
 

src/libman/package.cpp

 
 #include <libman/parse.hpp>
 
-#include <spdlog/fmt/fmt.h>
+#include <fmt/core.h>
 
 using namespace lm;
 

src/libman/parse.cpp

 
 #include <libman/util.hpp>
 
-#include <spdlog/fmt/fmt.h>
+#include <fmt/core.h>
 
 #include <cctype>
 #include <fstream>