[wpiutil] Upgrade to fmt 10.2.1, add wpi::print (#6161)

We now use a wrapper (wpi::print) to catch exceptions since we can't patch
std::print() to not throw when we ultimately migrate to it.

fmtlib and std format/print throw the same exceptions and always have. We previously patched fmt::print() to not throw a write failure exception, but we can't do that for std::print(); wpi::print() is the migration plan.

cameraserver/multiCameraServer/src/main/native/cpp/main.cpp

@@ -14,6 +14,7 @@
 #include <wpi/StringExtras.h>
 #include <wpi/fmt/raw_ostream.h>
 #include <wpi/json.h>
+#include <wpi/print.h>
 #include <wpi/raw_ostream.h>
 
 #include "cameraserver/CameraServer.h"
@@ -71,7 +72,7 @@ bool ReadCameraConfig(const wpi::json& config) {
   try {
     c.name = config.at("name").get<std::string>();
   } catch (const wpi::json::exception& e) {
-    fmt::print(stderr, "config error in '{}': could not read camera name: {}\n",
+    wpi::print(stderr, "config error in '{}': could not read camera name: {}\n",
                configFile, e.what());
     return false;
   }
@@ -80,7 +81,7 @@ bool ReadCameraConfig(const wpi::json& config) {
   try {
     c.path = config.at("path").get<std::string>();
   } catch (const wpi::json::exception& e) {
-    fmt::print(stderr,
+    wpi::print(stderr,
                "config error in '{}': camera '{}': could not read path: {}\n",
                configFile, c.name, e.what());
     return false;
@@ -98,7 +99,7 @@ bool ReadConfig() {
   std::unique_ptr<wpi::MemoryBuffer> fileBuffer =
       wpi::MemoryBuffer::GetFile(configFile, ec);
   if (fileBuffer == nullptr || ec) {
-    fmt::print(stderr, "could not open '{}': {}\n", configFile, ec.message());
+    wpi::print(stderr, "could not open '{}': {}\n", configFile, ec.message());
     return false;
   }
 
@@ -107,14 +108,14 @@ bool ReadConfig() {
   try {
     j = wpi::json::parse(fileBuffer->GetCharBuffer());
   } catch (const wpi::json::parse_error& e) {
-    fmt::print(stderr, "config error in '{}': byte {}: {}\n", configFile,
+    wpi::print(stderr, "config error in '{}': byte {}: {}\n", configFile,
                e.byte, e.what());
     return false;
   }
 
   // top level must be an object
   if (!j.is_object()) {
-    fmt::print(stderr, "config error in '{}': must be JSON object\n",
+    wpi::print(stderr, "config error in '{}': must be JSON object\n",
                configFile);
     return false;
   }
@@ -123,7 +124,7 @@ bool ReadConfig() {
   try {
     team = j.at("team").get<unsigned int>();
   } catch (const wpi::json::exception& e) {
-    fmt::print(stderr, "config error in '{}': could not read team number: {}\n",
+    wpi::print(stderr, "config error in '{}': could not read team number: {}\n",
                configFile, e.what());
     return false;
   }
@@ -137,13 +138,13 @@ bool ReadConfig() {
       } else if (wpi::equals_lower(str, "server")) {
         server = true;
       } else {
-        fmt::print(
+        wpi::print(
             stderr,
             "config error in '{}': could not understand ntmode value '{}'\n",
             configFile, str);
       }
     } catch (const wpi::json::exception& e) {
-      fmt::print(stderr, "config error in '{}': could not read ntmode: {}\n",
+      wpi::print(stderr, "config error in '{}': could not read ntmode: {}\n",
                  configFile, e.what());
     }
   }
@@ -156,7 +157,7 @@ bool ReadConfig() {
       }
     }
   } catch (const wpi::json::exception& e) {
-    fmt::print(stderr, "config error in '{}': could not read cameras: {}\n",
+    wpi::print(stderr, "config error in '{}': could not read cameras: {}\n",
                configFile, e.what());
     return false;
   }
@@ -165,7 +166,7 @@ bool ReadConfig() {
 }
 
 void StartCamera(const CameraConfig& config) {
-  fmt::print("Starting camera '{}' on {}\n", config.name, config.path);
+  wpi::print("Starting camera '{}' on {}\n", config.name, config.path);
   auto camera =
       frc::CameraServer::StartAutomaticCapture(config.name, config.path);
 
@@ -189,7 +190,7 @@ int main(int argc, char* argv[]) {
     std::puts("Setting up NetworkTables server");
     ntinst.StartServer();
   } else {
-    fmt::print("Setting up NetworkTables client for team {}\n", team);
+    wpi::print("Setting up NetworkTables client for team {}\n", team);
     ntinst.StartClient4("multicameraserver");
     ntinst.SetServerTeam(team);
   }

crossConnIntegrationTests/src/main/native/cpp/TestEnvironment.cpp

@@ -8,6 +8,7 @@
 #include <fmt/core.h>
 #include <gtest/gtest.h>
 #include <hal/HAL.h>
+#include <wpi/print.h>
 
 #include "mockds/MockDS.h"
 
@@ -27,7 +28,7 @@ class TestEnvironment : public testing::Environment {
     m_alreadySetUp = true;
 
     if (!HAL_Initialize(500, 0)) {
-      fmt::print(stderr, "FATAL ERROR: HAL could not be initialized\n");
+      wpi::print(stderr, "FATAL ERROR: HAL could not be initialized\n");
       std::exit(-1);
     }
 
@@ -39,7 +40,7 @@ class TestEnvironment : public testing::Environment {
     // able to run on the hardware.
     HAL_ObserveUserProgramStarting();
 
-    fmt::print("Started coms\n");
+    wpi::print("Started coms\n");
 
     int enableCounter = 0;
 
@@ -54,13 +55,13 @@ class TestEnvironment : public testing::Environment {
       if (enableCounter > 50) {
         // Robot did not enable properly after 5 seconds.
         // Force exit
-        fmt::print(stderr, " Failed to enable. Aborting\n");
+        wpi::print(stderr, " Failed to enable. Aborting\n");
         std::terminate();
       }
 
       std::this_thread::sleep_for(100ms);
 
-      fmt::print("Waiting for enable: {}\n", enableCounter++);
+      wpi::print("Waiting for enable: {}\n", enableCounter++);
       HAL_RefreshDSData();
     }
     std::this_thread::sleep_for(500ms);

crossConnIntegrationTests/src/main/native/cpp/mockds/MockDS.cpp

@@ -12,12 +12,13 @@
 #include <hal/cpp/fpga_clock.h>
 #include <wpi/Logger.h>
 #include <wpi/SmallVector.h>
+#include <wpi/print.h>
 #include <wpinet/UDPClient.h>
 
 static void LoggerFunc(unsigned int level, const char* file, unsigned int line,
                        const char* msg) {
   if (level == 20) {
-    fmt::print(stderr, "DS: {}\n", msg);
+    wpi::print(stderr, "DS: {}\n", msg);
     return;
   }
 
@@ -31,7 +32,7 @@ static void LoggerFunc(unsigned int level, const char* file, unsigned int line,
   } else {
     return;
   }
-  fmt::print(stderr, "DS: {}: {} ({}:{})\n", levelmsg, msg, file, line);
+  wpi::print(stderr, "DS: {}: {} ({}:{})\n", levelmsg, msg, file, line);
 }
 
 static void generateEnabledDsPacket(wpi::SmallVectorImpl<uint8_t>& data,

cscore/examples/enum_usb/enum_usb.cpp

@@ -4,7 +4,7 @@
 
 #include <cstdio>
 
-#include <fmt/format.h>
+#include <wpi/print.h>
 
 #include "cscore.h"
 
@@ -12,11 +12,11 @@ int main() {
   CS_Status status = 0;
 
   for (const auto& caminfo : cs::EnumerateUsbCameras(&status)) {
-    fmt::print("{}: {} ({})\n", caminfo.dev, caminfo.path, caminfo.name);
+    wpi::print("{}: {} ({})\n", caminfo.dev, caminfo.path, caminfo.name);
     if (!caminfo.otherPaths.empty()) {
       std::puts("Other device paths:");
       for (auto&& path : caminfo.otherPaths) {
-        fmt::print("  {}\n", path);
+        wpi::print("  {}\n", path);
       }
     }
 
@@ -24,26 +24,26 @@ int main() {
 
     std::puts("Properties:");
     for (const auto& prop : camera.EnumerateProperties()) {
-      fmt::print("  {}", prop.GetName());
+      wpi::print("  {}", prop.GetName());
       switch (prop.GetKind()) {
         case cs::VideoProperty::kBoolean:
-          fmt::print(" (bool): value={} default={}", prop.Get(),
+          wpi::print(" (bool): value={} default={}", prop.Get(),
                      prop.GetDefault());
           break;
         case cs::VideoProperty::kInteger:
-          fmt::print(" (int): value={} min={} max={} step={} default={}",
+          wpi::print(" (int): value={} min={} max={} step={} default={}",
                      prop.Get(), prop.GetMin(), prop.GetMax(), prop.GetStep(),
                      prop.GetDefault());
           break;
         case cs::VideoProperty::kString:
-          fmt::print(" (string): {}", prop.GetString());
+          wpi::print(" (string): {}", prop.GetString());
           break;
         case cs::VideoProperty::kEnum: {
-          fmt::print(" (enum): value={}", prop.Get());
+          wpi::print(" (enum): value={}", prop.Get());
           auto choices = prop.GetChoices();
           for (size_t i = 0; i < choices.size(); ++i) {
             if (!choices[i].empty()) {
-              fmt::print("\n    {}: {}", i, choices[i]);
+              wpi::print("\n    {}: {}", i, choices[i]);
             }
           }
           break;
@@ -71,7 +71,7 @@ int main() {
           pixelFormat = "Unknown";
           break;
       }
-      fmt::print("  PixelFormat:{} Width:{} Height:{} FPS:{}\n", pixelFormat,
+      wpi::print("  PixelFormat:{} Width:{} Height:{} FPS:{}\n", pixelFormat,
                  mode.width, mode.height, mode.fps);
     }
   }

cscore/examples/httpcvstream/httpcvstream.cpp

@@ -4,8 +4,8 @@
 
 #include <cstdio>
 
-#include <fmt/core.h>
 #include <opencv2/core/core.hpp>
+#include <wpi/print.h>
 
 #include "cscore.h"
 #include "cscore_cv.h"
@@ -24,10 +24,10 @@ int main() {
   for (;;) {
     uint64_t time = cvsink.GrabFrame(test);
     if (time == 0) {
-      fmt::print("error: {}\n", cvsink.GetError());
+      wpi::print("error: {}\n", cvsink.GetError());
       continue;
     }
-    fmt::print("got frame at time {} size ({}, {})\n", time, test.size().width,
+    wpi::print("got frame at time {} size ({}, {})\n", time, test.size().width,
                test.size().height);
     cv::flip(test, flip, 0);
     cvsource.PutFrame(flip);

cscore/examples/settings/settings.cpp

@@ -6,8 +6,8 @@
 #include <cstdio>
 #include <thread>
 
-#include <fmt/format.h>
 #include <wpi/StringExtras.h>
+#include <wpi/print.h>
 
 #include "cscore.h"
 
@@ -73,26 +73,26 @@ int main(int argc, char** argv) {
   // Print settings
   std::puts("Properties:");
   for (const auto& prop : camera.EnumerateProperties()) {
-    fmt::print("  {}", prop.GetName());
+    wpi::print("  {}", prop.GetName());
     switch (prop.GetKind()) {
       case cs::VideoProperty::kBoolean:
-        fmt::print(" (bool): value={} default={}", prop.Get(),
+        wpi::print(" (bool): value={} default={}", prop.Get(),
                    prop.GetDefault());
         break;
       case cs::VideoProperty::kInteger:
-        fmt::print(" (int): value={} min={} max={} step={} default={}",
+        wpi::print(" (int): value={} min={} max={} step={} default={}",
                    prop.Get(), prop.GetMin(), prop.GetMax(), prop.GetStep(),
                    prop.GetDefault());
         break;
       case cs::VideoProperty::kString:
-        fmt::print(" (string): {}", prop.GetString());
+        wpi::print(" (string): {}", prop.GetString());
         break;
       case cs::VideoProperty::kEnum: {
-        fmt::print(" (enum): value={}", prop.Get());
+        wpi::print(" (enum): value={}", prop.Get());
         auto choices = prop.GetChoices();
         for (size_t i = 0; i < choices.size(); ++i) {
           if (!choices[i].empty()) {
-            fmt::print("\n    {}: {}", i, choices[i]);
+            wpi::print("\n    {}: {}", i, choices[i]);
           }
         }
         break;

cscore/examples/usbcvstream/usbcvstream.cpp

@@ -2,8 +2,8 @@
 // Open Source Software; you can modify and/or share it under the terms of
 // the WPILib BSD license file in the root directory of this project.
 
-#include <fmt/core.h>
 #include <opencv2/core/core.hpp>
+#include <wpi/print.h>
 
 #include "cscore.h"
 #include "cscore_cv.h"
@@ -24,10 +24,10 @@ int main() {
   for (;;) {
     uint64_t time = cvsink.GrabFrame(test);
     if (time == 0) {
-      fmt::print("error: {}\n", cvsink.GetError());
+      wpi::print("error: {}\n", cvsink.GetError());
       continue;
     }
-    fmt::print("got frame at time {} size ({}, {})\n", time, test.size().width,
+    wpi::print("got frame at time {} size ({}, {})\n", time, test.size().width,
                test.size().height);
     cv::flip(test, flip, 0);
     cvsource.PutFrame(flip);

cscore/examples/usbstream/usbstream.cpp

@@ -4,15 +4,15 @@
 
 #include <cstdio>
 
-#include <fmt/format.h>
+#include <wpi/print.h>
 
 #include "cscore.h"
 
 int main() {
-  fmt::print("hostname: {}\n", cs::GetHostname());
+  wpi::print("hostname: {}\n", cs::GetHostname());
   std::puts("IPv4 network addresses:");
   for (const auto& addr : cs::GetNetworkInterfaces()) {
-    fmt::print("  {}\n", addr);
+    wpi::print("  {}\n", addr);
   }
   cs::UsbCamera camera{"usbcam", 0};
   camera.SetVideoMode(cs::VideoMode::kMJPEG, 320, 240, 30);
@@ -22,7 +22,7 @@ int main() {
   CS_Status status = 0;
   cs::AddListener(
       [&](const cs::RawEvent& event) {
-        fmt::print("FPS={} MBPS={}\n", camera.GetActualFPS(),
+        wpi::print("FPS={} MBPS={}\n", camera.GetActualFPS(),
                    (camera.GetActualDataRate() / 1000000.0));
       },
       cs::RawEvent::kTelemetryUpdated, false, &status);

cscore/examples/usbviewer/usbviewer.cpp

@@ -6,13 +6,12 @@
 #include <thread>
 #include <vector>
 
-#include <fmt/format.h>
-
 #define IMGUI_DEFINE_MATH_OPERATORS
 #include <imgui.h>
 #include <imgui_internal.h>
 #include <opencv2/core/core.hpp>
 #include <opencv2/imgproc.hpp>
+#include <wpi/print.h>
 #include <wpi/spinlock.h>
 #include <wpigui.h>
 
@@ -39,7 +38,7 @@ int main() {
       // get frame from camera
       uint64_t time = cvsink.GrabFrame(frame);
       if (time == 0) {
-        fmt::print("error: {}\n", cvsink.GetError());
+        wpi::print("error: {}\n", cvsink.GetError());
         continue;
       }
 

cscore/src/dev/native/cpp/main.cpp

@@ -2,10 +2,10 @@
 // Open Source Software; you can modify and/or share it under the terms of
 // the WPILib BSD license file in the root directory of this project.
 
-#include <fmt/core.h>
+#include <wpi/print.h>
 
 #include "cscore.h"
 
 int main() {
-  fmt::print("{}\n", cs::GetHostname());
+  wpi::print("{}\n", cs::GetHostname());
 }

cscore/src/main/native/cpp/Instance.cpp

@@ -8,13 +8,14 @@
 
 #include <fmt/format.h>
 #include <wpi/fs.h>
+#include <wpi/print.h>
 
 using namespace cs;
 
 static void def_log_func(unsigned int level, const char* file,
                          unsigned int line, const char* msg) {
   if (level == 20) {
-    fmt::print(stderr, "CS: {}\n", msg);
+    wpi::print(stderr, "CS: {}\n", msg);
     return;
   }
 
@@ -28,7 +29,7 @@ static void def_log_func(unsigned int level, const char* file,
   } else {
     return;
   }
-  fmt::print(stderr, "CS: {}: {} ({}:{})\n", levelmsg, msg,
+  wpi::print(stderr, "CS: {}: {} ({}:{})\n", levelmsg, msg,
              fs::path{file}.filename().string(), line);
 }
 

cscore/src/main/native/cpp/MjpegServerImpl.cpp

@@ -6,10 +6,10 @@
 
 #include <chrono>
 
-#include <fmt/format.h>
 #include <wpi/SmallString.h>
 #include <wpi/StringExtras.h>
 #include <wpi/fmt/raw_ostream.h>
+#include <wpi/print.h>
 #include <wpinet/HttpUtil.h>
 #include <wpinet/TCPAcceptor.h>
 #include <wpinet/raw_socket_istream.h>
@@ -135,7 +135,7 @@ class MjpegServerImpl::ConnThread : public wpi::SafeThread {
 static void SendHeader(wpi::raw_ostream& os, int code,
                        std::string_view codeText, std::string_view contentType,
                        std::string_view extra = {}) {
-  fmt::print(os, "HTTP/1.0 {} {}\r\n", code, codeText);
+  wpi::print(os, "HTTP/1.0 {} {}\r\n", code, codeText);
   os << "Connection: close\r\n"
         "Server: CameraServer/1.0\r\n"
         "Cache-Control: no-store, no-cache, must-revalidate, pre-check=0, "
@@ -302,7 +302,7 @@ bool MjpegServerImpl::ConnThread::ProcessCommand(wpi::raw_ostream& os,
       case CS_PROP_INTEGER:
       case CS_PROP_ENUM: {
         if (auto v = wpi::parse_integer<int>(value, 10)) {
-          fmt::print(response, "{}: {}\r\n", param, v.value());
+          wpi::print(response, "{}: {}\r\n", param, v.value());
           SDEBUG4("HTTP parameter \"{}\" value {}", param, value);
           source.SetProperty(prop, v.value(), &status);
         } else {
@@ -356,10 +356,10 @@ void MjpegServerImpl::ConnThread::SendHTML(wpi::raw_ostream& os,
       continue;
     }
     auto kind = source.GetPropertyKind(prop);
-    fmt::print(os, "<p /><label for=\"{0}\">{0}</label>\n", name);
+    wpi::print(os, "<p /><label for=\"{0}\">{0}</label>\n", name);
     switch (kind) {
       case CS_PROP_BOOLEAN:
-        fmt::print(os,
+        wpi::print(os,
                    "<input id=\"{0}\" type=\"checkbox\" "
                    "onclick=\"update('{0}', this.checked ? 1 : 0)\" ",
                    name);
@@ -374,12 +374,12 @@ void MjpegServerImpl::ConnThread::SendHTML(wpi::raw_ostream& os,
         auto min = source.GetPropertyMin(prop, &status);
         auto max = source.GetPropertyMax(prop, &status);
         auto step = source.GetPropertyStep(prop, &status);
-        fmt::print(os,
+        wpi::print(os,
                    "<input type=\"range\" min=\"{1}\" max=\"{2}\" "
                    "value=\"{3}\" id=\"{0}\" step=\"{4}\" "
                    "oninput=\"updateInt('#{0}op', '{0}', value)\" />\n",
                    name, min, max, valI, step);
-        fmt::print(os, "<output for=\"{0}\" id=\"{0}op\">{1}</output>\n", name,
+        wpi::print(os, "<output for=\"{0}\" id=\"{0}op\">{1}</output>\n", name,
                    valI);
         break;
       }
@@ -397,25 +397,25 @@ void MjpegServerImpl::ConnThread::SendHTML(wpi::raw_ostream& os,
           for (char ch : *choice) {
             ch_name.push_back(wpi::isPrint(ch) ? ch : ' ');
           }
-          fmt::print(os,
+          wpi::print(os,
                      "<input id=\"{0}{1}\" type=\"radio\" name=\"{0}\" "
                      "value=\"{2}\" onclick=\"update('{0}', {1})\"",
                      name, j, ch_name.str());
           if (j == valE) {
             os << " checked";
           }
-          fmt::print(os, " /><label for=\"{}{}\">{}</label>\n", name, j,
+          wpi::print(os, " /><label for=\"{}{}\">{}</label>\n", name, j,
                      ch_name.str());
         }
         break;
       }
       case CS_PROP_STRING: {
         wpi::SmallString<128> strval_buf;
-        fmt::print(os,
+        wpi::print(os,
                    "<input type=\"text\" id=\"{0}box\" name=\"{0}\" "
                    "value=\"{1}\" />\n",
                    name, source.GetStringProperty(prop, strval_buf, &status));
-        fmt::print(os,
+        wpi::print(os,
                    "<input type=\"button\" value =\"Submit\" "
                    "onclick=\"update('{0}', {0}box.value)\" />\n",
                    name);
@@ -471,7 +471,7 @@ void MjpegServerImpl::ConnThread::SendHTML(wpi::raw_ostream& os,
         os << "unknown";
         break;
     }
-    fmt::print(os, "</td><td>{}</td><td>{}</td><td>{}</td></tr>", mode.width,
+    wpi::print(os, "</td><td>{}</td><td>{}</td><td>{}</td></tr>", mode.width,
                mode.height, mode.fps);
   }
   os << "</table>\n";
@@ -500,21 +500,21 @@ void MjpegServerImpl::ConnThread::SendJSON(wpi::raw_ostream& os,
     wpi::SmallString<128> name_buf;
     auto name = source.GetPropertyName(prop, name_buf, &status);
     auto kind = source.GetPropertyKind(prop);
-    fmt::print(os, "\n\"name\": \"{}\"", name);
-    fmt::print(os, ",\n\"id\": \"{}\"", prop);
-    fmt::print(os, ",\n\"type\": \"{}\"", static_cast<int>(kind));
-    fmt::print(os, ",\n\"min\": \"{}\"", source.GetPropertyMin(prop, &status));
-    fmt::print(os, ",\n\"max\": \"{}\"", source.GetPropertyMax(prop, &status));
-    fmt::print(os, ",\n\"step\": \"{}\"",
+    wpi::print(os, "\n\"name\": \"{}\"", name);
+    wpi::print(os, ",\n\"id\": \"{}\"", prop);
+    wpi::print(os, ",\n\"type\": \"{}\"", static_cast<int>(kind));
+    wpi::print(os, ",\n\"min\": \"{}\"", source.GetPropertyMin(prop, &status));
+    wpi::print(os, ",\n\"max\": \"{}\"", source.GetPropertyMax(prop, &status));
+    wpi::print(os, ",\n\"step\": \"{}\"",
                source.GetPropertyStep(prop, &status));
-    fmt::print(os, ",\n\"default\": \"{}\"",
+    wpi::print(os, ",\n\"default\": \"{}\"",
                source.GetPropertyDefault(prop, &status));
     os << ",\n\"value\": \"";
     switch (kind) {
       case CS_PROP_BOOLEAN:
       case CS_PROP_INTEGER:
       case CS_PROP_ENUM:
-        fmt::print(os, "{}", source.GetProperty(prop, &status));
+        wpi::print(os, "{}", source.GetProperty(prop, &status));
         break;
       case CS_PROP_STRING: {
         wpi::SmallString<128> strval_buf;
@@ -544,7 +544,7 @@ void MjpegServerImpl::ConnThread::SendJSON(wpi::raw_ostream& os,
         for (char ch : *choice) {
           ch_name.push_back(std::isprint(ch) ? ch : ' ');
         }
-        fmt::print(os, "\"{}\": \"{}\"", j, ch_name.str());
+        wpi::print(os, "\"{}\": \"{}\"", j, ch_name.str());
       }
       os << "}\n";
     }
@@ -586,9 +586,9 @@ void MjpegServerImpl::ConnThread::SendJSON(wpi::raw_ostream& os,
         os << "unknown";
         break;
     }
-    fmt::print(os, "\",\n\"width\": \"{}\"", mode.width);
-    fmt::print(os, ",\n\"height\": \"{}\"", mode.height);
-    fmt::print(os, ",\n\"fps\": \"{}\"", mode.fps);
+    wpi::print(os, "\",\n\"width\": \"{}\"", mode.width);
+    wpi::print(os, ",\n\"height\": \"{}\"", mode.height);
+    wpi::print(os, ",\n\"fps\": \"{}\"", mode.fps);
     os << '}';
   }
   os << "\n]\n}\n";
@@ -773,8 +773,8 @@ void MjpegServerImpl::ConnThread::SendStream(wpi::raw_socket_ostream& os) {
     header.clear();
     oss << "\r\n--" BOUNDARY "\r\n"
         << "Content-Type: image/jpeg\r\n";
-    fmt::print(oss, "Content-Length: {}\r\n", size);
-    fmt::print(oss, "X-Timestamp: {}\r\n", timestamp);
+    wpi::print(oss, "Content-Length: {}\r\n", size);
+    wpi::print(oss, "X-Timestamp: {}\r\n", timestamp);
     oss << "\r\n";
     os << oss.str();
     if (addDHT) {

datalogtool/src/main/native/cpp/Exporter.cpp

@@ -30,6 +30,7 @@
 #include <wpi/fmt/raw_ostream.h>
 #include <wpi/fs.h>
 #include <wpi/mutex.h>
+#include <wpi/print.h>
 #include <wpi/raw_ostream.h>
 
 #include "App.h"
@@ -457,21 +458,21 @@ static void ValueToCsv(wpi::raw_ostream& os, const Entry& entry,
     int64_t val;
     if (record.GetInteger(&val)) {
       std::time_t timeval = val / 1000000;
-      fmt::print(os, "{:%Y-%m-%d %H:%M:%S}.{:06}", *std::localtime(&timeval),
+      wpi::print(os, "{:%Y-%m-%d %H:%M:%S}.{:06}", *std::localtime(&timeval),
                  val % 1000000);
       return;
     }
   } else if (entry.type == "double") {
     double val;
     if (record.GetDouble(&val)) {
-      fmt::print(os, "{}", val);
+      wpi::print(os, "{}", val);
       return;
     }
   } else if (entry.type == "int64" || entry.type == "int") {
     // support "int" for compatibility with old NT4 datalogs
     int64_t val;
     if (record.GetInteger(&val)) {
-      fmt::print(os, "{}", val);
+      wpi::print(os, "{}", val);
       return;
     }
   } else if (entry.type == "string" || entry.type == "json") {
@@ -484,31 +485,31 @@ static void ValueToCsv(wpi::raw_ostream& os, const Entry& entry,
   } else if (entry.type == "boolean") {
     bool val;
     if (record.GetBoolean(&val)) {
-      fmt::print(os, "{}", val);
+      wpi::print(os, "{}", val);
       return;
     }
   } else if (entry.type == "boolean[]") {
     std::vector<int> val;
     if (record.GetBooleanArray(&val)) {
-      fmt::print(os, "{}", fmt::join(val, ";"));
+      wpi::print(os, "{}", fmt::join(val, ";"));
       return;
     }
   } else if (entry.type == "double[]") {
     std::vector<double> val;
     if (record.GetDoubleArray(&val)) {
-      fmt::print(os, "{}", fmt::join(val, ";"));
+      wpi::print(os, "{}", fmt::join(val, ";"));
       return;
     }
   } else if (entry.type == "float[]") {
     std::vector<float> val;
     if (record.GetFloatArray(&val)) {
-      fmt::print(os, "{}", fmt::join(val, ";"));
+      wpi::print(os, "{}", fmt::join(val, ";"));
       return;
     }
   } else if (entry.type == "int64[]") {
     std::vector<int64_t> val;
     if (record.GetIntegerArray(&val)) {
-      fmt::print(os, "{}", fmt::join(val, ";"));
+      wpi::print(os, "{}", fmt::join(val, ";"));
       return;
     }
   } else if (entry.type == "string[]") {
@@ -527,7 +528,7 @@ static void ValueToCsv(wpi::raw_ostream& os, const Entry& entry,
       return;
     }
   }
-  fmt::print(os, "<invalid>");
+  wpi::print(os, "<invalid>");
 }
 
 static void ExportCsvFile(InputFile& f, wpi::raw_ostream& os, int style) {
@@ -575,13 +576,13 @@ static void ExportCsvFile(InputFile& f, wpi::raw_ostream& os, int style) {
       Entry* entry = entryIt->second;
 
       if (style == 0) {
-        fmt::print(os, "{},\"", record.GetTimestamp() / 1000000.0);
+        wpi::print(os, "{},\"", record.GetTimestamp() / 1000000.0);
         PrintEscapedCsvString(os, entry->name);
         os << '"' << ',';
         ValueToCsv(os, *entry, record);
         os << '\n';
       } else if (style == 1 && entry->column != -1) {
-        fmt::print(os, "{},", record.GetTimestamp() / 1000000.0);
+        wpi::print(os, "{},", record.GetTimestamp() / 1000000.0);
         for (int i = 0; i < entry->column; ++i) {
           os << ',';
         }

glass/src/lib/native/cpp/WindowManager.cpp

@@ -8,6 +8,7 @@
 #include <cstdio>
 
 #include <fmt/format.h>
+#include <wpi/print.h>
 #include <wpigui.h>
 
 #include "glass/Context.h"
@@ -31,7 +32,7 @@ Window* WindowManager::AddWindow(std::string_view id,
     return nullptr;
   }
   if (win->HasView()) {
-    fmt::print(stderr, "GUI: ignoring duplicate window '{}'\n", id);
+    wpi::print(stderr, "GUI: ignoring duplicate window '{}'\n", id);
     return nullptr;
   }
   win->SetView(MakeFunctionView(std::move(display)));
@@ -46,7 +47,7 @@ Window* WindowManager::AddWindow(std::string_view id,
     return nullptr;
   }
   if (win->HasView()) {
-    fmt::print(stderr, "GUI: ignoring duplicate window '{}'\n", id);
+    wpi::print(stderr, "GUI: ignoring duplicate window '{}'\n", id);
     return nullptr;
   }
   win->SetView(std::move(view));
@@ -61,7 +62,7 @@ Window* WindowManager::GetOrAddWindow(std::string_view id, bool duplicateOk,
       [](const auto& elem, std::string_view s) { return elem->GetId() < s; });
   if (it != m_windows.end() && (*it)->GetId() == id) {
     if (!duplicateOk) {
-      fmt::print(stderr, "GUI: ignoring duplicate window '{}'\n", id);
+      wpi::print(stderr, "GUI: ignoring duplicate window '{}'\n", id);
       return nullptr;
     }
     return it->get();

glass/src/lib/native/cpp/other/Field2D.cpp

@@ -12,7 +12,6 @@
 #include <utility>
 
 #include <fields/fields.h>
-#include <fmt/format.h>
 #include <frc/geometry/Pose2d.h>
 #include <frc/geometry/Rotation2d.h>
 #include <frc/geometry/Translation2d.h>
@@ -30,6 +29,7 @@
 #include <wpi/StringMap.h>
 #include <wpi/fs.h>
 #include <wpi/json.h>
+#include <wpi/print.h>
 #include <wpigui.h>
 
 #include "glass/Context.h"
@@ -450,7 +450,7 @@ bool FieldInfo::LoadJson(std::span<const char> is, std::string_view filename) {
   try {
     j = wpi::json::parse(is);
   } catch (const wpi::json::parse_error& e) {
-    fmt::print(stderr, "GUI: JSON: could not parse: {}\n", e.what());
+    wpi::print(stderr, "GUI: JSON: could not parse: {}\n", e.what());
     return false;
   }
 
@@ -465,7 +465,7 @@ bool FieldInfo::LoadJson(std::span<const char> is, std::string_view filename) {
   try {
     image = j.at("field-image").get<std::string>();
   } catch (const wpi::json::exception& e) {
-    fmt::print(stderr, "GUI: JSON: could not read field-image: {}\n", e.what());
+    wpi::print(stderr, "GUI: JSON: could not read field-image: {}\n", e.what());
     return false;
   }
 
@@ -477,7 +477,7 @@ bool FieldInfo::LoadJson(std::span<const char> is, std::string_view filename) {
     bottom = j.at("field-corners").at("bottom-right").at(1).get<int>();
     right = j.at("field-corners").at("bottom-right").at(0).get<int>();
   } catch (const wpi::json::exception& e) {
-    fmt::print(stderr, "GUI: JSON: could not read field-corners: {}\n",
+    wpi::print(stderr, "GUI: JSON: could not read field-corners: {}\n",
                e.what());
     return false;
   }
@@ -489,7 +489,7 @@ bool FieldInfo::LoadJson(std::span<const char> is, std::string_view filename) {
     width = j.at("field-size").at(0).get<float>();
     height = j.at("field-size").at(1).get<float>();
   } catch (const wpi::json::exception& e) {
-    fmt::print(stderr, "GUI: JSON: could not read field-size: {}\n", e.what());
+    wpi::print(stderr, "GUI: JSON: could not read field-size: {}\n", e.what());
     return false;
   }
 
@@ -498,7 +498,7 @@ bool FieldInfo::LoadJson(std::span<const char> is, std::string_view filename) {
   try {
     unit = j.at("field-unit").get<std::string>();
   } catch (const wpi::json::exception& e) {
-    fmt::print(stderr, "GUI: JSON: could not read field-unit: {}\n", e.what());
+    wpi::print(stderr, "GUI: JSON: could not read field-unit: {}\n", e.what());
     return false;
   }
 
@@ -512,7 +512,7 @@ bool FieldInfo::LoadJson(std::span<const char> is, std::string_view filename) {
   int fieldWidth = m_right - m_left;
   int fieldHeight = m_bottom - m_top;
   if (std::abs((fieldWidth / width) - (fieldHeight / height)) > 0.3) {
-    fmt::print(stderr,
+    wpi::print(stderr,
                "GUI: Field X and Y scaling substantially different: "
                "xscale={} yscale={}\n",
                (fieldWidth / width), (fieldHeight / height));
@@ -553,7 +553,7 @@ void FieldInfo::LoadJsonFile(std::string_view jsonfile) {
 }
 
 bool FieldInfo::LoadImageImpl(const std::string& fn) {
-  fmt::print("GUI: loading field image '{}'\n", fn);
+  wpi::print("GUI: loading field image '{}'\n", fn);
   auto texture = gui::Texture::CreateFromFile(fn.c_str());
   if (!texture) {
     std::puts("GUI: could not read field image");
@@ -745,7 +745,7 @@ void ObjectInfo::LoadImage() {
 }
 
 bool ObjectInfo::LoadImageImpl(const std::string& fn) {
-  fmt::print("GUI: loading object image '{}'\n", fn);
+  wpi::print("GUI: loading object image '{}'\n", fn);
   auto texture = gui::Texture::CreateFromFile(fn.c_str());
   if (!texture) {
     std::fputs("GUI: could not read object image\n", stderr);

glass/src/lib/native/cpp/other/Mechanism2D.cpp

@@ -11,7 +11,6 @@
 #include <string_view>
 #include <utility>
 
-#include <fmt/format.h>
 #include <frc/geometry/Pose2d.h>
 #include <frc/geometry/Rotation2d.h>
 #include <frc/geometry/Transform2d.h>
@@ -24,6 +23,7 @@
 #include <portable-file-dialogs.h>
 #include <units/angle.h>
 #include <units/length.h>
+#include <wpi/print.h>
 #include <wpigui.h>
 
 #include "glass/Context.h"
@@ -126,7 +126,7 @@ void BackgroundInfo::LoadImage() {
 }
 
 bool BackgroundInfo::LoadImageImpl(const std::string& fn) {
-  fmt::print("GUI: loading background image '{}'\n", fn);
+  wpi::print("GUI: loading background image '{}'\n", fn);
   auto texture = gui::Texture::CreateFromFile(fn.c_str());
   if (!texture) {
     std::puts("GUI: could not read background image");

glass/src/lib/native/cpp/support/DataLogReaderThread.cpp

@@ -6,8 +6,8 @@
 
 #include <utility>
 
-#include <fmt/format.h>
 #include <wpi/StringExtras.h>
+#include <wpi/print.h>
 
 using namespace glass;
 
@@ -36,7 +36,7 @@ void DataLogReaderThread::ReadMain() {
         std::scoped_lock lock{m_mutex};
         auto& entryPtr = m_entriesById[data.entry];
         if (entryPtr) {
-          fmt::print("...DUPLICATE entry ID, overriding\n");
+          wpi::print("...DUPLICATE entry ID, overriding\n");
         }
         auto [it, isNew] = m_entriesByName.emplace(data.name, data);
         if (isNew) {
@@ -50,7 +50,7 @@ void DataLogReaderThread::ReadMain() {
         }
         sigEntryAdded(data);
       } else {
-        fmt::print("Start(INVALID)\n");
+        wpi::print("Start(INVALID)\n");
       }
     } else if (record.IsFinish()) {
       int entry;
@@ -58,13 +58,13 @@ void DataLogReaderThread::ReadMain() {
         std::scoped_lock lock{m_mutex};
         auto it = m_entriesById.find(entry);
         if (it == m_entriesById.end()) {
-          fmt::print("...ID not found\n");
+          wpi::print("...ID not found\n");
         } else {
           it->second->ranges.back().m_end = recordIt;
           m_entriesById.erase(it);
         }
       } else {
-        fmt::print("Finish(INVALID)\n");
+        wpi::print("Finish(INVALID)\n");
       }
     } else if (record.IsSetMetadata()) {
       wpi::log::MetadataRecordData data;
@@ -72,15 +72,15 @@ void DataLogReaderThread::ReadMain() {
         std::scoped_lock lock{m_mutex};
         auto it = m_entriesById.find(data.entry);
         if (it == m_entriesById.end()) {
-          fmt::print("...ID not found\n");
+          wpi::print("...ID not found\n");
         } else {
           it->second->metadata = data.metadata;
         }
       } else {
-        fmt::print("SetMetadata(INVALID)\n");
+        wpi::print("SetMetadata(INVALID)\n");
       }
     } else if (record.IsControl()) {
-      fmt::print("Unrecognized control record\n");
+      wpi::print("Unrecognized control record\n");
     } else {
       auto it = schemaEntries.find(record.GetEntry());
       if (it != schemaEntries.end()) {
@@ -106,14 +106,14 @@ void DataLogReaderThread::ReadMain() {
       std::string err;
       auto desc = m_structDb.Add(typeStr, schema, &err);
       if (!desc) {
-        fmt::print("could not decode struct '{}' schema '{}': {}\n", name,
+        wpi::print("could not decode struct '{}' schema '{}': {}\n", name,
                    schema, err);
       }
     } else if (wpi::starts_with(name, "/.schema/proto:")) {
       // protobuf descriptor handling
       auto filename = wpi::drop_front(name, 15);
       if (!m_protoDb.Add(filename, data)) {
-        fmt::print("could not decode protobuf '{}' filename '{}'\n", name,
+        wpi::print("could not decode protobuf '{}' filename '{}'\n", name,
                    filename);
       }
     }

glass/src/libnt/native/cpp/NetworkTables.cpp

@@ -28,6 +28,7 @@
 #include <wpi/SpanExtras.h>
 #include <wpi/StringExtras.h>
 #include <wpi/mpack.h>
+#include <wpi/print.h>
 #include <wpi/raw_ostream.h>
 
 #include "glass/Context.h"
@@ -875,7 +876,7 @@ void NetworkTablesModel::Update() {
           std::string err;
           auto desc = m_structDb.Add(typeStr, schema, &err);
           if (!desc) {
-            fmt::print("could not decode struct '{}' schema '{}': {}\n",
+            wpi::print("could not decode struct '{}' schema '{}': {}\n",
                        entry->info.name, schema, err);
           } else if (desc->IsValid()) {
             // loop over all entries with this type and update
@@ -900,7 +901,7 @@ void NetworkTablesModel::Update() {
           // protobuf descriptor handling
           auto filename = wpi::drop_front(entry->info.name, 15);
           if (!m_protoDb.Add(filename, entry->value.GetRaw())) {
-            fmt::print("could not decode protobuf '{}' filename '{}'\n",
+            wpi::print("could not decode protobuf '{}' filename '{}'\n",
                        entry->info.name, filename);
           } else {
             // loop over all protobuf entries and update (conservatively)
@@ -1026,7 +1027,7 @@ void NetworkTablesModel::Client::UpdatePublishers(
   if (auto pubs = nt::meta::DecodeClientPublishers(data)) {
     publishers = std::move(*pubs);
   } else {
-    fmt::print(stderr, "Failed to update publishers\n");
+    wpi::print(stderr, "Failed to update publishers\n");
   }
 }
 
@@ -1039,7 +1040,7 @@ void NetworkTablesModel::Client::UpdateSubscribers(
       subscribers.emplace_back(std::move(sub));
     }
   } else {
-    fmt::print(stderr, "Failed to update subscribers\n");
+    wpi::print(stderr, "Failed to update subscribers\n");
   }
 }
 

hal/src/dev/native/cpp/main.cpp

@@ -3,10 +3,11 @@
 // the WPILib BSD license file in the root directory of this project.
 
 #include <fmt/core.h>
+#include <wpi/print.h>
 
 #include "hal/HAL.h"
 
 int main() {
-  fmt::print("Hello World\n");
-  fmt::print("{}\n", static_cast<int32_t>(HAL_GetRuntimeType()));
+  wpi::print("Hello World\n");
+  wpi::print("{}\n", static_cast<int32_t>(HAL_GetRuntimeType()));
 }

hal/src/main/native/athena/AnalogGyro.cpp

@@ -8,7 +8,7 @@
 #include <string>
 #include <thread>
 
-#include <fmt/format.h>
+#include <wpi/print.h>
 
 #include "AnalogInternal.h"
 #include "HALInitializer.h"
@@ -194,7 +194,7 @@ void HAL_CalibrateAnalogGyro(HAL_GyroHandle handle, int32_t* status) {
   if (*status != 0) {
     return;
   }
-  fmt::print("Calibrating analog gyro for {} seconds.\n",
+  wpi::print("Calibrating analog gyro for {} seconds.\n",
              kCalibrationSampleTime);
   Wait(kCalibrationSampleTime);
 

hal/src/main/native/athena/DMA.cpp

@@ -10,7 +10,7 @@
 #include <memory>
 #include <type_traits>
 
-#include <fmt/format.h>
+#include <wpi/print.h>
 
 #include "AnalogInternal.h"
 #include "ConstantsInternal.h"
@@ -737,7 +737,7 @@ enum HAL_DMAReadStatus HAL_ReadDMADirect(void* dmaPointer,
                      &remainingBytes, status);
 
   if ((remainingBytes % dma->captureStore.captureSize) != 0) {
-    fmt::print(
+    wpi::print(
         "Remaining bytes {} is not a multiple of capture size {}. This is "
         "likely a "
         "bug in WPILib. Please report this issue with a copy of your code.\n",

hal/src/main/native/athena/HAL.cpp

@@ -24,6 +24,7 @@
 #include <wpi/StringExtras.h>
 #include <wpi/fs.h>
 #include <wpi/mutex.h>
+#include <wpi/print.h>
 #include <wpi/timestamp.h>
 
 #include "FPGACalls.h"
@@ -500,14 +501,14 @@ static bool killExistingProgram(int timeout, int mode) {
       std::this_thread::sleep_for(std::chrono::milliseconds(timeout));
       if (kill(pid, 0) == 0) {
         // still not successful
-        fmt::print(
+        wpi::print(
             "FRC pid {} did not die within {} ms. Force killing with kill -9\n",
             pid, timeout);
         // Force kill -9
         auto forceKill = kill(pid, SIGKILL);
         if (forceKill != 0) {
           auto errorMsg = std::strerror(forceKill);
-          fmt::print("Kill -9 error: {}\n", errorMsg);
+          wpi::print("Kill -9 error: {}\n", errorMsg);
         }
         // Give a bit of time for the kill to take place
         std::this_thread::sleep_for(std::chrono::milliseconds(250));
@@ -533,20 +534,20 @@ static bool SetupNowRio(void) {
   Dl_info info;
   status = dladdr(reinterpret_cast<void*>(tHMB::create), &info);
   if (status == 0) {
-    fmt::print(stderr, "Failed to call dladdr on chipobject {}\n", dlerror());
+    wpi::print(stderr, "Failed to call dladdr on chipobject {}\n", dlerror());
     return false;
   }
 
   void* chipObjectLibrary = dlopen(info.dli_fname, RTLD_LAZY);
   if (chipObjectLibrary == nullptr) {
-    fmt::print(stderr, "Failed to call dlopen on chipobject {}\n", dlerror());
+    wpi::print(stderr, "Failed to call dlopen on chipobject {}\n", dlerror());
     return false;
   }
 
   std::unique_ptr<tHMB> hmb;
   hmb.reset(tHMB::create(&status));
   if (hmb == nullptr) {
-    fmt::print(stderr, "Failed to open HMB on chipobject {}\n", status);
+    wpi::print(stderr, "Failed to open HMB on chipobject {}\n", status);
     dlclose(chipObjectLibrary);
     return false;
   }
@@ -609,7 +610,7 @@ HAL_Bool HAL_Initialize(int32_t timeout, int32_t mode) {
 
   HAL_InitializeHMB(&status);
   if (status != 0) {
-    fmt::print(stderr, "Failed to open HAL HMB, status code {}\n", status);
+    wpi::print(stderr, "Failed to open HAL HMB, status code {}\n", status);
     return false;
   }
   hmbBuffer = HAL_GetHMBBuffer();

hal/src/main/native/athena/I2C.cpp

@@ -12,7 +12,7 @@
 
 #include <cstring>
 
-#include <fmt/format.h>
+#include <wpi/print.h>
 
 #include "DigitalInternal.h"
 #include "HALInitializer.h"
@@ -65,7 +65,7 @@ void HAL_InitializeI2C(HAL_I2CPort port, int32_t* status) {
     }
     int handle = open("/dev/i2c-2", O_RDWR);
     if (handle < 0) {
-      fmt::print("Failed to open onboard i2c bus: {}\n", std::strerror(errno));
+      wpi::print("Failed to open onboard i2c bus: {}\n", std::strerror(errno));
       return;
     }
     i2COnBoardHandle = handle;
@@ -88,7 +88,7 @@ void HAL_InitializeI2C(HAL_I2CPort port, int32_t* status) {
         digitalSystem->readEnableMXPSpecialFunction(status) | 0xC000, status);
     int handle = open("/dev/i2c-1", O_RDWR);
     if (handle < 0) {
-      fmt::print("Failed to open MXP i2c bus: {}\n", std::strerror(errno));
+      wpi::print("Failed to open MXP i2c bus: {}\n", std::strerror(errno));
       return;
     }
     i2CMXPHandle = handle;

hal/src/main/native/athena/Notifier.cpp

@@ -9,9 +9,9 @@
 #include <memory>
 #include <thread>
 
-#include <fmt/core.h>
 #include <wpi/condition_variable.h>
 #include <wpi/mutex.h>
+#include <wpi/print.h>
 
 #include "HALInitializer.h"
 #include "HALInternal.h"
@@ -164,12 +164,12 @@ HAL_NotifierHandle HAL_InitializeNotifier(int32_t* status) {
                           notifierThreadPriority, status);
     if (*status == HAL_THREAD_PRIORITY_ERROR) {
       *status = 0;
-      fmt::print("{}: HAL Notifier thread\n",
+      wpi::print("{}: HAL Notifier thread\n",
                  HAL_THREAD_PRIORITY_ERROR_MESSAGE);
     }
     if (*status == HAL_THREAD_PRIORITY_RANGE_ERROR) {
       *status = 0;
-      fmt::print("{}: HAL Notifier thread\n",
+      wpi::print("{}: HAL Notifier thread\n",
                  HAL_THREAD_PRIORITY_RANGE_ERROR_MESSAGE);
     }
 

hal/src/main/native/athena/SPI.cpp

@@ -14,8 +14,8 @@
 #include <cstdio>
 #include <cstring>
 
-#include <fmt/format.h>
 #include <wpi/mutex.h>
+#include <wpi/print.h>
 
 #include "DigitalInternal.h"
 #include "HALInitializer.h"
@@ -125,7 +125,7 @@ void HAL_InitializeSPI(HAL_SPIPort port, int32_t* status) {
       // CS0 is not a DIO port, so nothing to allocate
       handle = open("/dev/spidev0.0", O_RDWR);
       if (handle < 0) {
-        fmt::print("Failed to open SPI port {}: {}\n",
+        wpi::print("Failed to open SPI port {}: {}\n",
                    static_cast<int32_t>(port), std::strerror(errno));
         CommonSPIPortFree();
         return;
@@ -147,7 +147,7 @@ void HAL_InitializeSPI(HAL_SPIPort port, int32_t* status) {
       }
       handle = open("/dev/spidev0.1", O_RDWR);
       if (handle < 0) {
-        fmt::print("Failed to open SPI port {}: {}\n",
+        wpi::print("Failed to open SPI port {}: {}\n",
                    static_cast<int32_t>(port), std::strerror(errno));
         CommonSPIPortFree();
         HAL_FreeDIOPort(digitalHandles[0]);
@@ -170,7 +170,7 @@ void HAL_InitializeSPI(HAL_SPIPort port, int32_t* status) {
       }
       handle = open("/dev/spidev0.2", O_RDWR);
       if (handle < 0) {
-        fmt::print("Failed to open SPI port {}: {}\n",
+        wpi::print("Failed to open SPI port {}: {}\n",
                    static_cast<int32_t>(port), std::strerror(errno));
         CommonSPIPortFree();
         HAL_FreeDIOPort(digitalHandles[1]);
@@ -193,7 +193,7 @@ void HAL_InitializeSPI(HAL_SPIPort port, int32_t* status) {
       }
       handle = open("/dev/spidev0.3", O_RDWR);
       if (handle < 0) {
-        fmt::print("Failed to open SPI port {}: {}\n",
+        wpi::print("Failed to open SPI port {}: {}\n",
                    static_cast<int32_t>(port), std::strerror(errno));
         CommonSPIPortFree();
         HAL_FreeDIOPort(digitalHandles[2]);
@@ -240,7 +240,7 @@ void HAL_InitializeSPI(HAL_SPIPort port, int32_t* status) {
           digitalSystem->readEnableMXPSpecialFunction(status) | 0x00F0, status);
       handle = open("/dev/spidev1.0", O_RDWR);
       if (handle < 0) {
-        fmt::print("Failed to open SPI port {}: {}\n",
+        wpi::print("Failed to open SPI port {}: {}\n",
                    static_cast<int32_t>(port), std::strerror(errno));
         HAL_FreeDIOPort(digitalHandles[5]);  // free the first port allocated
         HAL_FreeDIOPort(digitalHandles[6]);  // free the second port allocated

hal/src/main/native/cpp/cpp/fpga_clock.cpp

@@ -7,7 +7,7 @@
 #include <cstdio>
 #include <limits>
 
-#include <fmt/format.h>
+#include <wpi/print.h>
 
 #include "hal/HALBase.h"
 
@@ -20,7 +20,7 @@ fpga_clock::time_point fpga_clock::now() noexcept {
   int32_t status = 0;
   uint64_t currentTime = HAL_GetFPGATime(&status);
   if (status != 0) {
-    fmt::print(
+    wpi::print(
         stderr,
         "Call to HAL_GetFPGATime failed in fpga_clock::now() with status {}. "
         "Initialization might have failed. Time will not be correct\n",

hal/src/main/native/sim/Extensions.cpp

@@ -8,10 +8,10 @@
 #include <string_view>
 #include <vector>
 
-#include <fmt/format.h>
 #include <wpi/SmallVector.h>
 #include <wpi/StringExtras.h>
 #include <wpi/fs.h>
+#include <wpi/print.h>
 #include <wpi/spinlock.h>
 
 #if defined(WIN32) || defined(_WIN32)
@@ -55,7 +55,7 @@ extern "C" {
 
 int HAL_LoadOneExtension(const char* library) {
   int rc = 1;  // It is expected and reasonable not to find an extra simulation
-  fmt::print("HAL Extensions: Attempting to load: {}\n",
+  wpi::print("HAL Extensions: Attempting to load: {}\n",
              fs::path{library}.stem().string());
   std::fflush(stdout);
   HTYPE handle = DLOPEN(library);
@@ -66,14 +66,14 @@ int HAL_LoadOneExtension(const char* library) {
 #else
     auto libraryName = fmt::format("lib{}.so", library);
 #endif
-    fmt::print("HAL Extensions: Load failed: {}\nTrying modified name: {}\n",
+    wpi::print("HAL Extensions: Load failed: {}\nTrying modified name: {}\n",
                DLERROR, fs::path{libraryName}.stem().string());
     std::fflush(stdout);
     handle = DLOPEN(libraryName.c_str());
   }
 #endif
   if (!handle) {
-    fmt::print("HAL Extensions: Failed to load library: {}\n", DLERROR);
+    wpi::print("HAL Extensions: Failed to load library: {}\n", DLERROR);
     std::fflush(stdout);
     return rc;
   }

hal/src/main/native/sim/MockHooks.cpp

@@ -8,7 +8,7 @@
 #include <cstdio>
 #include <thread>
 
-#include <fmt/format.h>
+#include <wpi/print.h>
 #include <wpi/timestamp.h>
 
 #include "MockHooksInternal.h"
@@ -84,7 +84,7 @@ void HALSIM_WaitForProgramStart(void) {
   int count = 0;
   while (!programStarted) {
     count++;
-    fmt::print("Waiting for program start signal: {}\n", count);
+    wpi::print("Waiting for program start signal: {}\n", count);
     std::this_thread::sleep_for(std::chrono::milliseconds(500));
   }
 }

ntcore/src/dev/native/cpp/main.cpp

@@ -13,7 +13,9 @@
 #include <thread>
 
 #include <fmt/format.h>
+#include <fmt/ranges.h>
 #include <wpi/Synchronization.h>
+#include <wpi/print.h>
 #include <wpi/timestamp.h>
 
 #include "ntcore.h"
@@ -43,7 +45,7 @@ int main(int argc, char* argv[]) {
 
   nt::SetEntryValue(myValue, nt::Value::MakeString("Hello World"));
 
-  fmt::print("{}\n", nt::GetEntryValue(myValue).GetString());
+  wpi::print("{}\n", nt::GetEntryValue(myValue).GetString());
 }
 
 void PrintTimes(std::vector<int64_t>& times) {
@@ -57,9 +59,9 @@ void PrintTimes(std::vector<int64_t>& times) {
       std::inner_product(times.begin(), times.end(), times.begin(), 0);
   double stdev = std::sqrt(sq_sum / times.size() - mean * mean);
 
-  fmt::print("min: {} max: {}, mean: {}, stdev: {}\n", min, max, mean, stdev);
-  fmt::print("min 10: {}\n", fmt::join(times.begin(), times.begin() + 10, ","));
-  fmt::print("max 10: {}\n", fmt::join(times.end() - 10, times.end(), ","));
+  wpi::print("min: {} max: {}, mean: {}, stdev: {}\n", min, max, mean, stdev);
+  wpi::print("min 10: {}\n", fmt::join(times.begin(), times.begin() + 10, ","));
+  wpi::print("max 10: {}\n", fmt::join(times.end() - 10, times.end(), ","));
 }
 
 // benchmark
@@ -115,11 +117,11 @@ void bench() {
   }
   auto stop = std::chrono::high_resolution_clock::now();
 
-  fmt::print("total time: {}us\n",
+  wpi::print("total time: {}us\n",
              std::chrono::duration_cast<std::chrono::microseconds>(stop - start)
                  .count());
   PrintTimes(times);
-  fmt::print("-- Flush --\n");
+  wpi::print("-- Flush --\n");
   PrintTimes(flushTimes);
 }
 
@@ -188,11 +190,11 @@ void bench2() {
   }
   auto stop = std::chrono::high_resolution_clock::now();
 
-  fmt::print("total time: {}us\n",
+  wpi::print("total time: {}us\n",
              std::chrono::duration_cast<std::chrono::microseconds>(stop - start)
                  .count());
   PrintTimes(times);
-  fmt::print("-- Flush --\n");
+  wpi::print("-- Flush --\n");
   PrintTimes(flushTimes);
 }
 

ntcore/src/main/native/cpp/LoggerImpl.cpp

@@ -4,10 +4,10 @@
 
 #include "LoggerImpl.h"
 
-#include <fmt/format.h>
 #include <wpi/Logger.h>
 #include <wpi/SmallVector.h>
 #include <wpi/fs.h>
+#include <wpi/print.h>
 
 #include "IListenerStorage.h"
 
@@ -16,7 +16,7 @@ using namespace nt;
 static void DefaultLogger(unsigned int level, const char* file,
                           unsigned int line, const char* msg) {
   if (level == wpi::WPI_LOG_INFO) {
-    fmt::print(stderr, "NT: {}\n", msg);
+    wpi::print(stderr, "NT: {}\n", msg);
     return;
   }
 
@@ -30,7 +30,7 @@ static void DefaultLogger(unsigned int level, const char* file,
   } else {
     return;
   }
-  fmt::print(stderr, "NT: {}: {} ({}:{})\n", levelmsg, msg, file, line);
+  wpi::print(stderr, "NT: {}: {} ({}:{})\n", levelmsg, msg, file, line);
 }
 
 static constexpr unsigned int kFlagCritical = 1u << 16;

ntcore/src/main/native/cpp/networktables/NetworkTableInstance.cpp

@@ -4,8 +4,8 @@
 
 #include "networktables/NetworkTableInstance.h"
 
-#include <fmt/format.h>
 #include <wpi/SmallVector.h>
+#include <wpi/print.h>
 
 #include "networktables/BooleanArrayTopic.h"
 #include "networktables/BooleanTopic.h"
@@ -105,7 +105,7 @@ NT_Listener NetworkTableInstance::AddListener(Topic topic,
                                               unsigned int eventMask,
                                               ListenerCallback listener) {
   if (::nt::GetInstanceFromHandle(topic.GetHandle()) != m_handle) {
-    fmt::print(stderr, "AddListener: topic is not from this instance\n");
+    wpi::print(stderr, "AddListener: topic is not from this instance\n");
     return 0;
   }
   return ::nt::AddListener(topic.GetHandle(), eventMask, std::move(listener));
@@ -115,7 +115,7 @@ NT_Listener NetworkTableInstance::AddListener(Subscriber& subscriber,
                                               unsigned int eventMask,
                                               ListenerCallback listener) {
   if (::nt::GetInstanceFromHandle(subscriber.GetHandle()) != m_handle) {
-    fmt::print(stderr, "AddListener: subscriber is not from this instance\n");
+    wpi::print(stderr, "AddListener: subscriber is not from this instance\n");
     return 0;
   }
   return ::nt::AddListener(subscriber.GetHandle(), eventMask,
@@ -126,7 +126,7 @@ NT_Listener NetworkTableInstance::AddListener(const NetworkTableEntry& entry,
                                               int eventMask,
                                               ListenerCallback listener) {
   if (::nt::GetInstanceFromHandle(entry.GetHandle()) != m_handle) {
-    fmt::print(stderr, "AddListener: entry is not from this instance\n");
+    wpi::print(stderr, "AddListener: entry is not from this instance\n");
     return 0;
   }
   return ::nt::AddListener(entry.GetHandle(), eventMask, std::move(listener));
@@ -136,7 +136,7 @@ NT_Listener NetworkTableInstance::AddListener(MultiSubscriber& subscriber,
                                               int eventMask,
                                               ListenerCallback listener) {
   if (::nt::GetInstanceFromHandle(subscriber.GetHandle()) != m_handle) {
-    fmt::print(stderr, "AddListener: subscriber is not from this instance\n");
+    wpi::print(stderr, "AddListener: subscriber is not from this instance\n");
     return 0;
   }
   return ::nt::AddListener(subscriber.GetHandle(), eventMask,

ntcoreffi/src/main/native/cpp/DataLogManager.cpp

@@ -15,6 +15,7 @@
 #include <wpi/SafeThread.h>
 #include <wpi/StringExtras.h>
 #include <wpi/fs.h>
+#include <wpi/print.h>
 #include <wpi/timestamp.h>
 
 #ifdef __FRC_ROBORIO__
@@ -310,7 +311,7 @@ void Thread::Main() {
             break;
           }
         } else {
-          fmt::print(stderr, "DataLogManager: could not delete {}\n",
+          wpi::print(stderr, "DataLogManager: could not delete {}\n",
                      entry.path().string());
         }
       }
@@ -461,7 +462,7 @@ Instance::Instance(std::string_view dir, std::string_view filename,
     if (wpi::starts_with(entry.path().stem().string(), "FRC_TBD_") &&
         entry.path().extension() == ".wpilog") {
       if (!fs::remove(entry, ec)) {
-        fmt::print(stderr, "DataLogManager: could not delete {}\n",
+        wpi::print(stderr, "DataLogManager: could not delete {}\n",
                    entry.path().string());
       }
     }
@@ -493,7 +494,7 @@ void DataLogManager::Stop() {
 
 void DataLogManager::Log(std::string_view message) {
   GetInstance().owner.GetThread()->m_messageLog.Append(message);
-  fmt::print("{}\n", message);
+  wpi::print("{}\n", message);
 }
 
 wpi::log::DataLog& DataLogManager::GetLog() {

simulation/halsim_ds_socket/src/main/native/cpp/main.cpp

@@ -20,8 +20,8 @@
 #include <string_view>
 
 #include <DSCommPacket.h>
-#include <fmt/format.h>
 #include <hal/Extensions.h>
+#include <wpi/print.h>
 #include <wpinet/EventLoopRunner.h>
 #include <wpinet/raw_uv_ostream.h>
 #include <wpinet/uv/Tcp.h>
@@ -119,7 +119,7 @@ static void SetupUdp(wpi::uv::Loop& loop) {
   simLoopTimer->timeout.connect([udpLocal = udp.get(), simAddr] {
     udpLocal->Send(simAddr, {singleByte.get(), 1}, [](auto buf, Error err) {
       if (err) {
-        fmt::print(stderr, "{}\n", err.str());
+        wpi::print(stderr, "{}\n", err.str());
         std::fflush(stderr);
       }
     });
@@ -131,7 +131,7 @@ static void SetupUdp(wpi::uv::Loop& loop) {
     try {
       timeoutMs = std::stoi(envTimeout);
     } catch (const std::exception& e) {
-      fmt::print(stderr, "Error parsing DS_TIMEOUT_MS: {}\n", e.what());
+      wpi::print(stderr, "Error parsing DS_TIMEOUT_MS: {}\n", e.what());
     }
   }
   auto autoDisableTimer = Timer::Create(loop);
@@ -158,7 +158,7 @@ static void SetupUdp(wpi::uv::Loop& loop) {
         udpLocal->Send(outAddr, sendBufs, [](auto bufs, Error err) {
           GetBufferPool().Release(bufs);
           if (err) {
-            fmt::print(stderr, "{}\n", err.str());
+            wpi::print(stderr, "{}\n", err.str());
             std::fflush(stderr);
           }
         });

simulation/halsim_ws_client/src/dev/native/cpp/main.cpp

@@ -4,10 +4,10 @@
 
 #include <thread>
 
-#include <fmt/core.h>
 #include <hal/DriverStation.h>
 #include <hal/HALBase.h>
 #include <hal/Main.h>
+#include <wpi/print.h>
 
 extern "C" int HALSIM_InitExtension(void);
 
@@ -21,9 +21,9 @@ int main() {
   while (cycleCount < 100) {
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
     cycleCount++;
-    fmt::print("Count: {}\n", cycleCount);
+    wpi::print("Count: {}\n", cycleCount);
   }
 
-  fmt::print("DONE\n");
+  wpi::print("DONE\n");
   HAL_ExitMain();
 }

simulation/halsim_ws_client/src/main/native/cpp/HALSimWS.cpp

@@ -6,10 +6,10 @@
 
 #include <cstdio>
 
-#include <fmt/format.h>
 #include <wpi/SmallString.h>
 #include <wpi/SmallVector.h>
 #include <wpi/StringExtras.h>
+#include <wpi/print.h>
 #include <wpinet/uv/util.h>
 
 #include "HALSimWSClientConnection.h"
@@ -26,7 +26,7 @@ HALSimWS::HALSimWS(wpi::uv::Loop& loop, ProviderContainer& providers,
       m_providers(providers),
       m_simDevicesProvider(simDevicesProvider) {
   m_loop.error.connect([](uv::Error err) {
-    fmt::print(stderr, "HALSim WS Client libuv Error: {}\n", err.str());
+    wpi::print(stderr, "HALSim WS Client libuv Error: {}\n", err.str());
   });
 
   m_tcp_client = uv::Tcp::Create(m_loop);
@@ -54,7 +54,7 @@ bool HALSimWS::Initialize() {
     try {
       m_port = std::stoi(port);
     } catch (const std::invalid_argument& err) {
-      fmt::print(stderr, "Error decoding HALSIMWS_PORT ({})\n", err.what());
+      wpi::print(stderr, "Error decoding HALSIMWS_PORT ({})\n", err.what());
       return false;
     }
   } else {
@@ -109,16 +109,16 @@ void HALSimWS::Start() {
 
   // Print any filters we are using
   if (m_useMsgFiltering) {
-    fmt::print("WS Message Filters:");
+    wpi::print("WS Message Filters:");
     for (auto filter : m_msgFilters.keys()) {
-      fmt::print("* \"{}\"\n", filter);
+      wpi::print("* \"{}\"\n", filter);
     }
   } else {
-    fmt::print("No WS Message Filters specified");
+    wpi::print("No WS Message Filters specified");
   }
 
   // Set up the connection timer
-  fmt::print("Will attempt to connect to ws://{}:{}{}\n", m_host, m_port,
+  wpi::print("Will attempt to connect to ws://{}:{}{}\n", m_host, m_port,
              m_uri);
 
   // Set up the timer to attempt connection
@@ -132,7 +132,7 @@ void HALSimWS::Start() {
 void HALSimWS::AttemptConnect() {
   m_connect_attempts++;
 
-  fmt::print("Connection Attempt {}\n", m_connect_attempts);
+  wpi::print("Connection Attempt {}\n", m_connect_attempts);
 
   struct sockaddr_in dest;
   uv::NameToAddr(m_host, m_port, &dest);
@@ -197,7 +197,7 @@ void HALSimWS::OnNetValueChanged(const wpi::json& msg) {
       provider->OnNetValueChanged(msg.at("data"));
     }
   } catch (wpi::json::exception& e) {
-    fmt::print(stderr, "Error with incoming message: {}\n", e.what());
+    wpi::print(stderr, "Error with incoming message: {}\n", e.what());
   }
 }
 

simulation/halsim_ws_client/src/main/native/cpp/HALSimWSClientConnection.cpp

@@ -6,7 +6,7 @@
 
 #include <cstdio>
 
-#include <fmt/format.h>
+#include <wpi/print.h>
 #include <wpinet/raw_uv_ostream.h>
 
 #include "HALSimWS.h"
@@ -52,7 +52,7 @@ void HALSimWSClientConnection::Initialize() {
     } catch (const wpi::json::parse_error& e) {
       std::string err("JSON parse failed: ");
       err += e.what();
-      fmt::print(stderr, "{}\n", err);
+      wpi::print(stderr, "{}\n", err);
       m_websocket->Fail(1003, err);
       return;
     }
@@ -82,7 +82,7 @@ void HALSimWSClientConnection::OnSimValueChanged(const wpi::json& msg) {
       return;
     }
   } catch (wpi::json::exception& e) {
-    fmt::print(stderr, "Error with message: {}\n", e.what());
+    wpi::print(stderr, "Error with message: {}\n", e.what());
   }
 
   wpi::SmallVector<uv::Buffer, 4> sendBufs;
@@ -103,7 +103,7 @@ void HALSimWSClientConnection::OnSimValueChanged(const wpi::json& msg) {
                                   }
 
                                   if (err) {
-                                    fmt::print(stderr, "{}\n", err.str());
+                                    wpi::print(stderr, "{}\n", err.str());
                                     std::fflush(stderr);
                                   }
                                 });

simulation/halsim_ws_server/src/dev/native/cpp/main.cpp

@@ -5,10 +5,10 @@
 #include <cstdio>
 #include <thread>
 
-#include <fmt/format.h>
 #include <hal/DriverStation.h>
 #include <hal/HALBase.h>
 #include <hal/Main.h>
+#include <wpi/print.h>
 
 extern "C" int HALSIM_InitExtension(void);
 
@@ -24,7 +24,7 @@ int main() {
   while (cycleCount < 1000) {
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
     cycleCount++;
-    fmt::print("Count: {}\n", cycleCount);
+    wpi::print("Count: {}\n", cycleCount);
   }
 
   std::puts("DONE");

simulation/halsim_ws_server/src/main/native/cpp/HALSimHttpConnection.cpp

@@ -8,11 +8,11 @@
 
 #include <string_view>
 
-#include <fmt/format.h>
 #include <wpi/MemoryBuffer.h>
 #include <wpi/SmallVector.h>
 #include <wpi/StringExtras.h>
 #include <wpi/fs.h>
+#include <wpi/print.h>
 #include <wpinet/MimeTypes.h>
 #include <wpinet/UrlParser.h>
 #include <wpinet/raw_uv_ostream.h>
@@ -83,7 +83,7 @@ void HALSimHttpConnection::OnSimValueChanged(const wpi::json& msg) {
       return;
     }
   } catch (wpi::json::exception& e) {
-    fmt::print(stderr, "Error with message: {}\n", e.what());
+    wpi::print(stderr, "Error with message: {}\n", e.what());
   }
 
   // render json to buffers
@@ -104,7 +104,7 @@ void HALSimHttpConnection::OnSimValueChanged(const wpi::json& msg) {
                                   }
 
                                   if (err) {
-                                    fmt::print(stderr, "{}\n", err.str());
+                                    wpi::print(stderr, "{}\n", err.str());
                                     std::fflush(stderr);
                                   }
                                 });
@@ -201,6 +201,6 @@ void HALSimHttpConnection::MySendError(int code, std::string_view message) {
 
 void HALSimHttpConnection::Log(int code) {
   auto method = wpi::http_method_str(m_request.GetMethod());
-  fmt::print(stderr, "{} {} HTTP/{}.{} {}\n", method, m_request.GetUrl(),
+  wpi::print(stderr, "{} {} HTTP/{}.{} {}\n", method, m_request.GetUrl(),
              m_request.GetMajor(), m_request.GetMinor(), code);
 }

simulation/halsim_ws_server/src/main/native/cpp/HALSimWeb.cpp

@@ -4,9 +4,9 @@
 
 #include "HALSimWeb.h"
 
-#include <fmt/format.h>
 #include <wpi/SmallString.h>
 #include <wpi/fs.h>
+#include <wpi/print.h>
 #include <wpinet/UrlParser.h>
 #include <wpinet/WebSocketServer.h>
 #include <wpinet/raw_uv_ostream.h>
@@ -25,7 +25,7 @@ HALSimWeb::HALSimWeb(wpi::uv::Loop& loop, ProviderContainer& providers,
       m_providers(providers),
       m_simDevicesProvider(simDevicesProvider) {
   m_loop.error.connect([](uv::Error err) {
-    fmt::print(stderr, "HALSim WS Server libuv ERROR: {}\n", err.str());
+    wpi::print(stderr, "HALSim WS Server libuv ERROR: {}\n", err.str());
   });
 
   m_server = uv::Tcp::Create(m_loop);
@@ -70,7 +70,7 @@ bool HALSimWeb::Initialize() {
     try {
       m_port = std::stoi(port);
     } catch (const std::invalid_argument& err) {
-      fmt::print(stderr, "Error decoding HALSIMWS_PORT ({})\n", err.what());
+      wpi::print(stderr, "Error decoding HALSIMWS_PORT ({})\n", err.what());
       return false;
     }
   } else {
@@ -114,17 +114,17 @@ void HALSimWeb::Start() {
 
   // start listening for incoming connections
   m_server->Listen();
-  fmt::print("Listening at http://localhost:{}\n", m_port);
-  fmt::print("WebSocket URI: {}\n", m_uri);
+  wpi::print("Listening at http://localhost:{}\n", m_port);
+  wpi::print("WebSocket URI: {}\n", m_uri);
 
   // Print any filters we are using
   if (m_useMsgFiltering) {
-    fmt::print("WS Message Filters:");
+    wpi::print("WS Message Filters:");
     for (auto filter : m_msgFilters.keys()) {
-      fmt::print("* \"{}\"\n", filter);
+      wpi::print("* \"{}\"\n", filter);
     }
   } else {
-    fmt::print("No WS Message Filters specified");
+    wpi::print("No WS Message Filters specified");
   }
 }
 
@@ -180,7 +180,7 @@ void HALSimWeb::OnNetValueChanged(const wpi::json& msg) {
       provider->OnNetValueChanged(msg.at("data"));
     }
   } catch (wpi::json::exception& e) {
-    fmt::print(stderr, "Error with incoming message: {}\n", e.what());
+    wpi::print(stderr, "Error with incoming message: {}\n", e.what());
   }
 }
 

simulation/halsim_ws_server/src/test/native/cpp/WebServerClientTest.cpp

@@ -6,8 +6,8 @@
 
 #include <cstdio>
 
-#include <fmt/format.h>
 #include <wpi/SmallString.h>
+#include <wpi/print.h>
 #include <wpinet/raw_uv_ostream.h>
 #include <wpinet/uv/util.h>
 
@@ -20,7 +20,7 @@ namespace wpilibws {
 // Create Web Socket and specify event callbacks
 void WebServerClientTest::InitializeWebSocket(const std::string& host, int port,
                                               const std::string& uri) {
-  fmt::print("Will attempt to connect to: {}:{}{}\n", host, port, uri);
+  wpi::print("Will attempt to connect to: {}:{}{}\n", host, port, uri);
   m_websocket = wpi::WebSocket::CreateClient(*m_tcp_client.get(), uri,
                                              fmt::format("{}:{}", host, port));
 
@@ -46,7 +46,7 @@ void WebServerClientTest::InitializeWebSocket(const std::string& host, int port,
     } catch (const wpi::json::parse_error& e) {
       std::string err("JSON parse failed: ");
       err += e.what();
-      fmt::print(stderr, "{}\n", err);
+      wpi::print(stderr, "{}\n", err);
       m_websocket->Fail(1003, err);
       return;
     }
@@ -65,7 +65,7 @@ void WebServerClientTest::InitializeWebSocket(const std::string& host, int port,
 // Create tcp client, specify callbacks, and create timers for loop
 bool WebServerClientTest::Initialize() {
   m_loop.error.connect(
-      [](uv::Error err) { fmt::print(stderr, "uv Error: {}\n", err.str()); });
+      [](uv::Error err) { wpi::print(stderr, "uv Error: {}\n", err.str()); });
 
   m_tcp_client = uv::Tcp::Create(m_loop);
   if (!m_tcp_client) {
@@ -106,7 +106,7 @@ bool WebServerClientTest::Initialize() {
 
 void WebServerClientTest::AttemptConnect() {
   m_connect_attempts++;
-  fmt::print("Test Client Connection Attempt {}\n", m_connect_attempts);
+  wpi::print("Test Client Connection Attempt {}\n", m_connect_attempts);
 
   if (m_connect_attempts >= 5) {
     std::fputs("Test Client Timeout. Unable to connect\n", stderr);
@@ -144,7 +144,7 @@ void WebServerClientTest::SendMessage(const wpi::json& msg) {
         m_buffers->Release(bufs);
       }
       if (err) {
-        fmt::print(stderr, "{}\n", err.str());
+        wpi::print(stderr, "{}\n", err.str());
         std::fflush(stderr);
       }
     });

simulation/halsim_ws_server/src/test/native/cpp/main.cpp

@@ -4,12 +4,12 @@
 
 #include <thread>
 
-#include <fmt/format.h>
 #include <gtest/gtest.h>
 #include <hal/DriverStation.h>
 #include <hal/HALBase.h>
 #include <hal/Main.h>
 #include <hal/simulation/DIOData.h>
+#include <wpi/print.h>
 #include <wpinet/uv/Loop.h>
 
 #include "HALSimWSServer.h"
@@ -55,7 +55,7 @@ TEST_F(WebServerIntegrationTest, DISABLED_DigitalOutput) {
         return;
       }
       if (IsConnectedClientWS()) {
-        fmt::print("***** Setting DIO value for pin {} to {}\n", PIN,
+        wpi::print("***** Setting DIO value for pin {} to {}\n", PIN,
                    (EXPECTED_VALUE ? "true" : "false"));
         HALSIM_SetDIOValue(PIN, EXPECTED_VALUE);
         done = true;
@@ -83,7 +83,7 @@ TEST_F(WebServerIntegrationTest, DISABLED_DigitalOutput) {
       test_value = it.value();
     }
   } catch (wpi::json::exception& e) {
-    fmt::print(stderr, "Error with incoming message: {}\n", e.what());
+    wpi::print(stderr, "Error with incoming message: {}\n", e.what());
   }
 
   // Compare results
@@ -109,7 +109,7 @@ TEST_F(WebServerIntegrationTest, DISABLED_DigitalInput) {
         wpi::json msg = {{"type", "DIO"},
                          {"device", std::to_string(PIN)},
                          {"data", {{"<>value", EXPECTED_VALUE}}}};
-        fmt::print("***** Input JSON: {}\n", msg.dump());
+        wpi::print("***** Input JSON: {}\n", msg.dump());
         m_webserverClient->SendMessage(msg);
         done = true;
       }
@@ -144,7 +144,7 @@ TEST_F(WebServerIntegrationTest, DriverStation) {
             {"type", "DriverStation"},
             {"device", ""},
             {"data", {{">enabled", EXPECTED_VALUE}, {">new_data", true}}}};
-        fmt::print("***** Input JSON: {}\n", msg.dump());
+        wpi::print("***** Input JSON: {}\n", msg.dump());
         m_webserverClient->SendMessage(msg);
         done = true;
       }

simulation/halsim_xrp/src/main/native/cpp/HALSimXRP.cpp

@@ -6,10 +6,10 @@
 
 #include <cstdio>
 
-#include <fmt/format.h>
 #include <wpi/Endian.h>
 #include <wpi/MathExtras.h>
 #include <wpi/SmallString.h>
+#include <wpi/print.h>
 #include <wpinet/raw_uv_ostream.h>
 #include <wpinet/uv/util.h>
 
@@ -24,7 +24,7 @@ HALSimXRP::HALSimXRP(wpi::uv::Loop& loop,
       m_providers(providers),
       m_simDevicesProvider(simDevicesProvider) {
   m_loop.error.connect([](uv::Error err) {
-    fmt::print(stderr, "HALSim XRP Client libuv Error: {}\n", err.str());
+    wpi::print(stderr, "HALSim XRP Client libuv Error: {}\n", err.str());
   });
 
   m_udp_client = uv::Udp::Create(m_loop);
@@ -51,7 +51,7 @@ bool HALSimXRP::Initialize() {
     try {
       m_port = std::stoi(port);
     } catch (const std::invalid_argument& err) {
-      fmt::print(stderr, "Error decoding HALSIMXRP_PORT ({})\n", err.what());
+      wpi::print(stderr, "Error decoding HALSIMXRP_PORT ({})\n", err.what());
       return false;
     }
   } else {
@@ -79,7 +79,7 @@ void HALSimXRP::Start() {
         ParsePacket({reinterpret_cast<uint8_t*>(data.base), len});
       });
 
-  m_udp_client->closed.connect([]() { fmt::print("Socket Closed\n"); });
+  m_udp_client->closed.connect([]() { wpi::print("Socket Closed\n"); });
 
   // Fake the OnNetworkConnected call
   auto hws = shared_from_this();
@@ -120,7 +120,7 @@ void HALSimXRP::OnNetValueChanged(const wpi::json& msg) {
       provider->OnNetValueChanged(msg.at("data"));
     }
   } catch (wpi::json::exception& e) {
-    fmt::print(stderr, "Error with incoming message: {}\n", e.what());
+    wpi::print(stderr, "Error with incoming message: {}\n", e.what());
   }
 }
 

sysid/src/main/native/cpp/App.cpp

@@ -10,7 +10,6 @@
 #include <memory>
 #include <string_view>
 
-#include <fmt/format.h>
 #include <glass/Context.h>
 #include <glass/MainMenuBar.h>
 #include <glass/Storage.h>
@@ -20,6 +19,7 @@
 #include <imgui.h>
 #include <uv.h>
 #include <wpi/Logger.h>
+#include <wpi/print.h>
 #include <wpigui.h>
 #include <wpigui_openurl.h>
 
@@ -89,7 +89,7 @@ void Application(std::string_view saveDir) {
     std::string filename = std::filesystem::path{file}.filename().string();
     gLog.Append(fmt::format("{}{} ({}:{})\n", lvl, msg, filename, line));
 #ifndef NDEBUG
-    fmt::print(stderr, "{}{} ({}:{})\n", lvl, msg, filename, line);
+    wpi::print(stderr, "{}{} ({}:{})\n", lvl, msg, filename, line);
 #endif
   });
 

upstream_utils/fmt_patches/0001-Don-t-throw-on-write-failure.patch

@@ -1,55 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Tyler Veness <calcmogul@gmail.com>
-Date: Wed, 18 May 2022 10:21:49 -0700
-Subject: [PATCH 1/3] Don't throw on write failure
-
----
- include/fmt/format-inl.h | 4 +---
- include/fmt/xchar.h      | 3 +--
- src/os.cc                | 4 +---
- 3 files changed, 3 insertions(+), 8 deletions(-)
-
-diff --git a/include/fmt/format-inl.h b/include/fmt/format-inl.h
-index dac2d437a41ab7b0b4e72895212b5a972ada73a9..af6ba74d618f29c77339e8a82906cccd26a2efa4 100644
---- a/include/fmt/format-inl.h
-+++ b/include/fmt/format-inl.h
-@@ -75,9 +75,7 @@ FMT_FUNC void report_error(format_func func, int error_code,
- // A wrapper around fwrite that throws on error.
- inline void fwrite_fully(const void* ptr, size_t size, size_t count,
-                          FILE* stream) {
--  size_t written = std::fwrite(ptr, size, count, stream);
--  if (written < count)
--    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
-+  std::fwrite(ptr, size, count, stream);
- }
- 
- #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
-diff --git a/include/fmt/xchar.h b/include/fmt/xchar.h
-index 625ec36922e9bcc44a76b3c40792cb08ede63813..0f79c1720a4c855bb7088381e93af08eae56d66c 100644
---- a/include/fmt/xchar.h
-+++ b/include/fmt/xchar.h
-@@ -220,8 +220,7 @@ inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) {
-   auto buf = wmemory_buffer();
-   detail::vformat_to(buf, fmt, args);
-   buf.push_back(L'\0');
--  if (std::fputws(buf.data(), f) == -1)
--    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
-+  std::fputws(buf.data(), f);
- }
- 
- inline void vprint(wstring_view fmt, wformat_args args) {
-diff --git a/src/os.cc b/src/os.cc
-index bca410e945e0347d349e06179906a43b38b56a5c..d7ded50f9870a885d1ce1835fecc4f740858127a 100644
---- a/src/os.cc
-+++ b/src/os.cc
-@@ -258,9 +258,7 @@ long long file::size() const {
- std::size_t file::read(void* buffer, std::size_t count) {
-   rwresult result = 0;
-   FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count))));
--  if (result < 0)
--    FMT_THROW(system_error(errno, FMT_STRING("cannot read from file")));
--  return detail::to_unsigned(result);
-+  return count;
- }
- 
- std::size_t file::write(const void* buffer, std::size_t count) {

upstream_utils/fmt_patches/0001-Suppress-warnings-we-can-t-fix.patch

@@ -1,17 +1,17 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Tyler Veness <calcmogul@gmail.com>
 Date: Tue, 16 May 2023 13:49:18 -0700
-Subject: [PATCH 2/3] Suppress warnings we can't fix
+Subject: [PATCH] Suppress warnings we can't fix
 
 ---
  include/fmt/format.h | 7 +++++++
  1 file changed, 7 insertions(+)
 
 diff --git a/include/fmt/format.h b/include/fmt/format.h
-index 87a34b972ce6af4e2209e4d6cf78e8401e8f0037..ac0f52def2f3e2bc88d11903f5532efd89af454d 100644
+index 7637c8a0d0687ae3b77a145c2e1ceadf7fe5f67d..bfc6d70d1c5de100b3e413d61f7394cbb3b644f1 100644
 --- a/include/fmt/format.h
 +++ b/include/fmt/format.h
-@@ -1324,7 +1324,14 @@ inline auto equal2(const char* lhs, const char* rhs) -> bool {
+@@ -1289,7 +1289,14 @@ inline auto equal2(const char* lhs, const char* rhs) -> bool {
  template <typename Char>
  FMT_CONSTEXPR20 FMT_INLINE void copy2(Char* dst, const char* src) {
    if (!is_constant_evaluated() && sizeof(Char) == sizeof(char)) {

upstream_utils/fmt_patches/0003-Remove-this-from-decltype.patch

@@ -1,39 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Peter Johnson <johnson.peter@gmail.com>
-Date: Mon, 20 Nov 2023 23:29:02 -0800
-Subject: [PATCH 3/3] Remove this from decltype
-
-This doesn't work on the most recent version of MSVC.
----
- include/fmt/core.h | 6 +++---
- 1 file changed, 3 insertions(+), 3 deletions(-)
-
-diff --git a/include/fmt/core.h b/include/fmt/core.h
-index 1fe13888a00263a085032272482475e5dafbef26..915d8952d5f6d5255f5a1aab956ef56245b80dc4 100644
---- a/include/fmt/core.h
-+++ b/include/fmt/core.h
-@@ -1435,7 +1435,7 @@ template <typename Context> struct arg_mapper {
-   // Only map owning types because mapping views can be unsafe.
-   template <typename T, typename U = format_as_t<T>,
-             FMT_ENABLE_IF(std::is_arithmetic<U>::value)>
--  FMT_CONSTEXPR FMT_INLINE auto map(const T& val) -> decltype(this->map(U())) {
-+  FMT_CONSTEXPR FMT_INLINE auto map(const T& val) -> decltype(map(U())) {
-     return map(format_as(val));
-   }
- 
-@@ -1459,13 +1459,13 @@ template <typename Context> struct arg_mapper {
-                           !is_string<U>::value && !is_char<U>::value &&
-                           !is_named_arg<U>::value &&
-                           !std::is_arithmetic<format_as_t<U>>::value)>
--  FMT_CONSTEXPR FMT_INLINE auto map(T& val) -> decltype(this->do_map(val)) {
-+  FMT_CONSTEXPR FMT_INLINE auto map(T& val) -> decltype(do_map(val)) {
-     return do_map(val);
-   }
- 
-   template <typename T, FMT_ENABLE_IF(is_named_arg<T>::value)>
-   FMT_CONSTEXPR FMT_INLINE auto map(const T& named_arg)
--      -> decltype(this->map(named_arg.value)) {
-+      -> decltype(map(named_arg.value)) {
-     return map(named_arg.value);
-   }
- 

upstream_utils/llvm_patches/0019-Prefer-fmtlib.patch

@@ -16,7 +16,7 @@ index 3a88178cfbbcf7062a958c7de820247bc913ab33..54137a331ca9e752b02c0f16ae996094
  #include "llvm/Support/Threading.h"
  #include "llvm/Support/WindowsError.h"
 -#include "llvm/Support/raw_ostream.h"
-+#include "fmt/format.h"
++#include "wpi/print.h"
  #include <cassert>
  #include <cstdlib>
  #include <mutex>
@@ -33,7 +33,7 @@ index 3a88178cfbbcf7062a958c7de820247bc913ab33..54137a331ca9e752b02c0f16ae996094
 -    std::string_view MessageStr = OS.str();
 -    ssize_t written = ::write(2, MessageStr.data(), MessageStr.size());
 -    (void)written; // If something went wrong, we deliberately just give up.
-+    fmt::print(stderr, "LLVM ERROR: {}\n", Reason);
++    wpi::print(stderr, "LLVM ERROR: {}\n", Reason);
    }
  
    // If we reached here, we are failing ungracefully. Run the interrupt handlers
@@ -43,13 +43,13 @@ index 3a88178cfbbcf7062a958c7de820247bc913ab33..54137a331ca9e752b02c0f16ae996094
    if (msg)
 -    dbgs() << msg << "\n";
 -  dbgs() << "UNREACHABLE executed";
-+    fmt::print(stderr, "{}\n", msg);
++    wpi::print(stderr, "{}\n", msg);
 +  std::fputs("UNREACHABLE executed", stderr);
    if (file)
 -    dbgs() << " at " << file << ":" << line;
 -  dbgs() << "!\n";
-+    fmt::print(stderr, " at {}:{}", file, line);
-+  fmt::print(stderr, "!\n");
++    wpi::print(stderr, " at {}:{}", file, line);
++  wpi::print(stderr, "!\n");
    abort();
  #ifdef LLVM_BUILTIN_UNREACHABLE
    // Windows systems and possibly others don't declare abort() to be noreturn,

upstream_utils/llvm_patches/0022-OS-specific-changes.patch

@@ -12,7 +12,7 @@ index e253d6f7a5ca3aee75823efdb9717dcd93fff5dc..5c08e469e2e44b27e69f4aa974bc59de
 --- a/llvm/lib/Support/ErrorHandling.cpp
 +++ b/llvm/lib/Support/ErrorHandling.cpp
 @@ -96,15 +96,7 @@ void llvm::report_fatal_error(std::string_view Reason, bool GenCrashDiag) {
-     fmt::print(stderr, "LLVM ERROR: {}\n", Reason);
+     wpi::print(stderr, "LLVM ERROR: {}\n", Reason);
    }
  
 -  // If we reached here, we are failing ungracefully. Run the interrupt handlers

upstream_utils/update_fmt.py

@@ -13,16 +13,14 @@ from upstream_utils import (
 
 
 def main():
-    upstream_root = clone_repo("https://github.com/fmtlib/fmt", "10.1.1")
+    upstream_root = clone_repo("https://github.com/fmtlib/fmt", "10.2.1")
     wpilib_root = get_repo_root()
     wpiutil = os.path.join(wpilib_root, "wpiutil")
 
     # Apply patches to upstream Git repo
     os.chdir(upstream_root)
     for f in [
-        "0001-Don-t-throw-on-write-failure.patch",
-        "0002-Suppress-warnings-we-can-t-fix.patch",
-        "0003-Remove-this-from-decltype.patch",
+        "0001-Suppress-warnings-we-can-t-fix.patch",
     ]:
         git_am(os.path.join(wpilib_root, "upstream_utils/fmt_patches", f))
 

wpilibNewCommands/src/main/native/cpp/frc2/command/PrintCommand.cpp

@@ -4,12 +4,12 @@
 
 #include "frc2/command/PrintCommand.h"
 
-#include <fmt/format.h>
+#include <wpi/print.h>
 
 using namespace frc2;
 
 PrintCommand::PrintCommand(std::string_view message)
-    : CommandHelper{[str = std::string(message)] { fmt::print("{}\n", str); },
+    : CommandHelper{[str = std::string(message)] { wpi::print("{}\n", str); },
                     {}} {}
 
 bool PrintCommand::RunsWhenDisabled() const {

wpilibc/src/dev/native/cpp/main.cpp

@@ -4,11 +4,12 @@
 
 #include <fmt/core.h>
 #include <hal/HALBase.h>
+#include <wpi/print.h>
 
 #include "WPILibVersion.h"
 
 int main() {
-  fmt::print("Hello World\n");
-  fmt::print("{}\n", static_cast<int32_t>(HAL_GetRuntimeType()));
-  fmt::print("{}\n", GetWPILibVersion());
+  wpi::print("Hello World\n");
+  wpi::print("{}\n", static_cast<int32_t>(HAL_GetRuntimeType()));
+  wpi::print("{}\n", GetWPILibVersion());
 }

wpilibc/src/main/native/cpp/DataLogManager.cpp

@@ -11,12 +11,12 @@
 #include <random>
 
 #include <fmt/chrono.h>
-#include <fmt/format.h>
 #include <networktables/NetworkTableInstance.h>
 #include <wpi/DataLog.h>
 #include <wpi/SafeThread.h>
 #include <wpi/StringExtras.h>
 #include <wpi/fs.h>
+#include <wpi/print.h>
 #include <wpi/timestamp.h>
 
 #include "frc/DriverStation.h"
@@ -157,7 +157,7 @@ void Thread::Main() {
             break;
           }
         } else {
-          fmt::print(stderr, "DataLogManager: could not delete {}\n",
+          wpi::print(stderr, "DataLogManager: could not delete {}\n",
                      entry.path().string());
         }
       }
@@ -307,7 +307,7 @@ Instance::Instance(std::string_view dir, std::string_view filename,
     if (wpi::starts_with(entry.path().stem().string(), "FRC_TBD_") &&
         entry.path().extension() == ".wpilog") {
       if (!fs::remove(entry, ec)) {
-        fmt::print(stderr, "DataLogManager: could not delete {}\n",
+        wpi::print(stderr, "DataLogManager: could not delete {}\n",
                    entry.path().string());
       }
     }
@@ -339,7 +339,7 @@ void DataLogManager::Stop() {
 
 void DataLogManager::Log(std::string_view message) {
   GetInstance().owner.GetThread()->m_messageLog.Append(message);
-  fmt::print("{}\n", message);
+  wpi::print("{}\n", message);
 }
 
 wpi::log::DataLog& DataLogManager::GetLog() {

wpilibc/src/main/native/cpp/IterativeRobotBase.cpp

@@ -6,10 +6,10 @@
 
 #include <frc/DriverStation.h>
 
-#include <fmt/format.h>
 #include <hal/DriverStation.h>
 #include <hal/FRCUsageReporting.h>
 #include <networktables/NetworkTableInstance.h>
+#include <wpi/print.h>
 
 #include "frc/DSControlWord.h"
 #include "frc/Errors.h"
@@ -40,7 +40,7 @@ void IterativeRobotBase::TestInit() {}
 void IterativeRobotBase::RobotPeriodic() {
   static bool firstRun = true;
   if (firstRun) {
-    fmt::print("Default {}() method... Override me!\n", __FUNCTION__);
+    wpi::print("Default {}() method... Override me!\n", __FUNCTION__);
     firstRun = false;
   }
 }
@@ -48,7 +48,7 @@ void IterativeRobotBase::RobotPeriodic() {
 void IterativeRobotBase::SimulationPeriodic() {
   static bool firstRun = true;
   if (firstRun) {
-    fmt::print("Default {}() method... Override me!\n", __FUNCTION__);
+    wpi::print("Default {}() method... Override me!\n", __FUNCTION__);
     firstRun = false;
   }
 }
@@ -56,7 +56,7 @@ void IterativeRobotBase::SimulationPeriodic() {
 void IterativeRobotBase::DisabledPeriodic() {
   static bool firstRun = true;
   if (firstRun) {
-    fmt::print("Default {}() method... Override me!\n", __FUNCTION__);
+    wpi::print("Default {}() method... Override me!\n", __FUNCTION__);
     firstRun = false;
   }
 }
@@ -64,7 +64,7 @@ void IterativeRobotBase::DisabledPeriodic() {
 void IterativeRobotBase::AutonomousPeriodic() {
   static bool firstRun = true;
   if (firstRun) {
-    fmt::print("Default {}() method... Override me!\n", __FUNCTION__);
+    wpi::print("Default {}() method... Override me!\n", __FUNCTION__);
     firstRun = false;
   }
 }
@@ -72,7 +72,7 @@ void IterativeRobotBase::AutonomousPeriodic() {
 void IterativeRobotBase::TeleopPeriodic() {
   static bool firstRun = true;
   if (firstRun) {
-    fmt::print("Default {}() method... Override me!\n", __FUNCTION__);
+    wpi::print("Default {}() method... Override me!\n", __FUNCTION__);
     firstRun = false;
   }
 }
@@ -80,7 +80,7 @@ void IterativeRobotBase::TeleopPeriodic() {
 void IterativeRobotBase::TestPeriodic() {
   static bool firstRun = true;
   if (firstRun) {
-    fmt::print("Default {}() method... Override me!\n", __FUNCTION__);
+    wpi::print("Default {}() method... Override me!\n", __FUNCTION__);
     firstRun = false;
   }
 }

wpilibc/src/main/native/cppcs/RobotBase.cpp

@@ -11,10 +11,10 @@
 #include <cstdio>
 
 #include <cameraserver/CameraServerShared.h>
-#include <fmt/format.h>
 #include <hal/FRCUsageReporting.h>
 #include <hal/HALBase.h>
 #include <networktables/NetworkTableInstance.h>
+#include <wpi/print.h>
 #include <wpi/timestamp.h>
 #include <wpimath/MathShared.h>
 
@@ -244,7 +244,7 @@ RobotBase::RobotBase() {
     std::this_thread::sleep_for(10ms);
     ++count;
     if (count > 100) {
-      fmt::print(stderr, "timed out while waiting for NT server to start\n");
+      wpi::print(stderr, "timed out while waiting for NT server to start\n");
       break;
     }
   }

wpilibcExamples/src/main/cpp/templates/timed/cpp/Robot.cpp

@@ -4,8 +4,8 @@
 
 #include "Robot.h"
 
-#include <fmt/core.h>
 #include <frc/smartdashboard/SmartDashboard.h>
+#include <wpi/print.h>
 
 void Robot::RobotInit() {
   m_chooser.SetDefaultOption(kAutoNameDefault, kAutoNameDefault);
@@ -38,7 +38,7 @@ void Robot::AutonomousInit() {
   m_autoSelected = m_chooser.GetSelected();
   // m_autoSelected = SmartDashboard::GetString("Auto Selector",
   //     kAutoNameDefault);
-  fmt::print("Auto selected: {}\n", m_autoSelected);
+  wpi::print("Auto selected: {}\n", m_autoSelected);
 
   if (m_autoSelected == kAutoNameCustom) {
     // Custom Auto goes here

wpilibcExamples/src/main/cpp/templates/timeslice/cpp/Robot.cpp

@@ -4,9 +4,9 @@
 
 #include "Robot.h"
 
-#include <fmt/core.h>
 #include <frc/livewindow/LiveWindow.h>
 #include <frc/smartdashboard/SmartDashboard.h>
+#include <wpi/print.h>
 
 // Run robot periodic() functions for 5 ms, and run controllers every 10 ms
 Robot::Robot() : frc::TimesliceRobot{5_ms, 10_ms} {
@@ -56,7 +56,7 @@ void Robot::AutonomousInit() {
   m_autoSelected = m_chooser.GetSelected();
   // m_autoSelected = SmartDashboard::GetString("Auto Selector",
   //     kAutoNameDefault);
-  fmt::print("Auto selected: {}\n", m_autoSelected);
+  wpi::print("Auto selected: {}\n", m_autoSelected);
 
   if (m_autoSelected == kAutoNameCustom) {
     // Custom Auto goes here

wpilibcIntegrationTests/src/main/native/cpp/NotifierTest.cpp

@@ -4,8 +4,8 @@
 
 #include "frc/Notifier.h"  // NOLINT(build/include_order)
 
-#include <fmt/core.h>
 #include <gtest/gtest.h>
+#include <wpi/print.h>
 
 #include "frc/Timer.h"
 
@@ -20,13 +20,13 @@ TEST(NotifierTest, StartPeriodicAndStop) {
   notifier.Stop();
   EXPECT_EQ(10u, counter) << "Received " << counter
                           << " notifications in 10.5 seconds\n";
-  fmt::print("Received {} notifications in 10.5 seconds\n", counter);
+  wpi::print("Received {} notifications in 10.5 seconds\n", counter);
 
   frc::Wait(3_s);
 
   EXPECT_EQ(10u, counter) << "Received " << counter - 10
                           << " notifications in 3 seconds\n";
-  fmt::print("Received {} notifications in 3 seconds\n", counter - 10);
+  wpi::print("Received {} notifications in 3 seconds\n", counter - 10);
 }
 
 TEST(NotifierTest, StartSingle) {
@@ -39,5 +39,5 @@ TEST(NotifierTest, StartSingle) {
 
   EXPECT_EQ(1u, counter) << "Received " << counter
                          << " notifications in 10.5 seconds\n";
-  fmt::print("Received {} notifications in 10.5 seconds\n", counter);
+  wpi::print("Received {} notifications in 10.5 seconds\n", counter);
 }

wpilibcIntegrationTests/src/main/native/cpp/TestEnvironment.cpp

@@ -5,9 +5,9 @@
 #include <cstdlib>
 #include <thread>
 
-#include <fmt/core.h>
 #include <gtest/gtest.h>
 #include <hal/HAL.h>
+#include <wpi/print.h>
 
 #include "frc/DriverStation.h"
 #include "frc/livewindow/LiveWindow.h"
@@ -29,7 +29,7 @@ class TestEnvironment : public testing::Environment {
     m_alreadySetUp = true;
 
     if (!HAL_Initialize(500, 0)) {
-      fmt::print(stderr, "FATAL ERROR: HAL could not be initialized\n");
+      wpi::print(stderr, "FATAL ERROR: HAL could not be initialized\n");
       std::exit(-1);
     }
 
@@ -42,7 +42,7 @@ class TestEnvironment : public testing::Environment {
     HAL_ObserveUserProgramStarting();
     frc::LiveWindow::SetEnabled(false);
 
-    fmt::print("Started coms\n");
+    wpi::print("Started coms\n");
 
     int enableCounter = 0;
     frc::DriverStation::RefreshData();
@@ -50,13 +50,13 @@ class TestEnvironment : public testing::Environment {
       if (enableCounter > 50) {
         // Robot did not enable properly after 5 seconds.
         // Force exit
-        fmt::print(stderr, " Failed to enable. Aborting\n");
+        wpi::print(stderr, " Failed to enable. Aborting\n");
         std::terminate();
       }
 
       std::this_thread::sleep_for(100ms);
 
-      fmt::print("Waiting for enable: {}\n", enableCounter++);
+      wpi::print("Waiting for enable: {}\n", enableCounter++);
       frc::DriverStation::RefreshData();
     }
   }

wpilibcIntegrationTests/src/main/native/cpp/mockds/MockDS.cpp

@@ -8,16 +8,16 @@
 
 #include <string_view>
 
-#include <fmt/core.h>
 #include <hal/cpp/fpga_clock.h>
 #include <wpi/Logger.h>
 #include <wpi/SmallVector.h>
+#include <wpi/print.h>
 #include <wpinet/UDPClient.h>
 
 static void LoggerFunc(unsigned int level, const char* file, unsigned int line,
                        const char* msg) {
   if (level == 20) {
-    fmt::print(stderr, "DS: {}\n", msg);
+    wpi::print(stderr, "DS: {}\n", msg);
     return;
   }
 
@@ -31,7 +31,7 @@ static void LoggerFunc(unsigned int level, const char* file, unsigned int line,
   } else {
     return;
   }
-  fmt::print(stderr, "DS: {}: {} ({}:{})\n", levelmsg, msg, file, line);
+  wpi::print(stderr, "DS: {}: {} ({}:{})\n", levelmsg, msg, file, line);
 }
 
 static void generateEnabledDsPacket(wpi::SmallVectorImpl<uint8_t>& data,

wpimath/src/dev/native/cpp/main.cpp

@@ -4,8 +4,8 @@
 
 #include <numbers>
 
-#include <fmt/core.h>
+#include <wpi/print.h>
 
 int main() {
-  fmt::print("{}\n", std::numbers::pi);
+  wpi::print("{}\n", std::numbers::pi);
 }

wpimath/src/main/native/cpp/trajectory/TrajectoryGenerator.cpp

@@ -6,7 +6,7 @@
 
 #include <utility>
 
-#include <fmt/format.h>
+#include <wpi/print.h>
 
 #include "frc/spline/SplineHelper.h"
 #include "frc/spline/SplineParameterizer.h"
@@ -22,7 +22,7 @@ void TrajectoryGenerator::ReportError(const char* error) {
   if (s_errorFunc) {
     s_errorFunc(error);
   } else {
-    fmt::print(stderr, "TrajectoryGenerator error: {}\n", error);
+    wpi::print(stderr, "TrajectoryGenerator error: {}\n", error);
   }
 }
 

wpimath/src/test/native/cpp/DARETestUtil.cpp

@@ -5,8 +5,8 @@
 #include "DARETestUtil.h"
 
 #include <Eigen/Eigenvalues>
-#include <fmt/core.h>
 #include <gtest/gtest.h>
+#include <wpi/print.h>
 
 #include "frc/fmt/Eigen.h"
 
@@ -20,9 +20,9 @@ void ExpectMatrixEqual(const Eigen::MatrixXd& lhs, const Eigen::MatrixXd& rhs,
   }
 
   if (::testing::Test::HasFailure()) {
-    fmt::print("lhs =\n{}\n", lhs);
-    fmt::print("rhs =\n{}\n", rhs);
-    fmt::print("delta =\n{}\n", Eigen::MatrixXd{lhs - rhs});
+    wpi::print("lhs =\n{}\n", lhs);
+    wpi::print("rhs =\n{}\n", rhs);
+    wpi::print("delta =\n{}\n", Eigen::MatrixXd{lhs - rhs});
   }
 }
 

wpimath/src/test/native/cpp/UnitsTest.cpp

@@ -8,6 +8,7 @@
 #include <type_traits>
 
 #include <gtest/gtest.h>
+#include <wpi/print.h>
 
 #include "units/acceleration.h"
 #include "units/angle.h"
@@ -1426,59 +1427,59 @@ TEST_F(UnitContainer, cout) {
 #if __has_include(<fmt/format.h>) && !defined(UNIT_LIB_DISABLE_FMT)
 TEST_F(UnitContainer, fmtlib) {
   testing::internal::CaptureStdout();
-  fmt::print("{}", degree_t(349.87));
+  wpi::print("{}", degree_t(349.87));
   std::string output = testing::internal::GetCapturedStdout();
   EXPECT_STREQ("349.87 deg", output.c_str());
 
   testing::internal::CaptureStdout();
-  fmt::print("{}", meter_t(1.0));
+  wpi::print("{}", meter_t(1.0));
   output = testing::internal::GetCapturedStdout();
   EXPECT_STREQ("1 m", output.c_str());
 
   testing::internal::CaptureStdout();
-  fmt::print("{}", dB_t(31.0));
+  wpi::print("{}", dB_t(31.0));
   output = testing::internal::GetCapturedStdout();
   EXPECT_STREQ("31 dB", output.c_str());
 
   testing::internal::CaptureStdout();
-  fmt::print("{}", volt_t(21.79));
+  wpi::print("{}", volt_t(21.79));
   output = testing::internal::GetCapturedStdout();
   EXPECT_STREQ("21.79 V", output.c_str());
 
   testing::internal::CaptureStdout();
-  fmt::print("{}", dBW_t(12.0));
+  wpi::print("{}", dBW_t(12.0));
   output = testing::internal::GetCapturedStdout();
   EXPECT_STREQ("12 dBW", output.c_str());
 
   testing::internal::CaptureStdout();
-  fmt::print("{}", dBm_t(120.0));
+  wpi::print("{}", dBm_t(120.0));
   output = testing::internal::GetCapturedStdout();
   EXPECT_STREQ("120 dBm", output.c_str());
 
   testing::internal::CaptureStdout();
-  fmt::print("{}", miles_per_hour_t(72.1));
+  wpi::print("{}", miles_per_hour_t(72.1));
   output = testing::internal::GetCapturedStdout();
   EXPECT_STREQ("72.1 mph", output.c_str());
 
   // undefined unit
   testing::internal::CaptureStdout();
-  fmt::print("{}", units::math::cpow<4>(meter_t(2)));
+  wpi::print("{}", units::math::cpow<4>(meter_t(2)));
   output = testing::internal::GetCapturedStdout();
   EXPECT_STREQ("16 m^4", output.c_str());
 
   testing::internal::CaptureStdout();
-  fmt::print("{}", units::math::cpow<3>(foot_t(2)));
+  wpi::print("{}", units::math::cpow<3>(foot_t(2)));
   output = testing::internal::GetCapturedStdout();
   EXPECT_STREQ("8 cu_ft", output.c_str());
 
   testing::internal::CaptureStdout();
-  fmt::print("{:.9}", units::math::cpow<4>(foot_t(2)));
+  wpi::print("{:.9}", units::math::cpow<4>(foot_t(2)));
   output = testing::internal::GetCapturedStdout();
   EXPECT_STREQ("0.138095597 m^4", output.c_str());
 
   // constants
   testing::internal::CaptureStdout();
-  fmt::print("{:.8}", constants::k_B);
+  wpi::print("{:.8}", constants::k_B);
   output = testing::internal::GetCapturedStdout();
 #if defined(_MSC_VER) && (_MSC_VER <= 1800)
   EXPECT_STREQ("1.3806485e-023 m^2 kg s^-2 K^-1", output.c_str());
@@ -1487,7 +1488,7 @@ TEST_F(UnitContainer, fmtlib) {
 #endif
 
   testing::internal::CaptureStdout();
-  fmt::print("{:.9}", constants::mu_B);
+  wpi::print("{:.9}", constants::mu_B);
   output = testing::internal::GetCapturedStdout();
 #if defined(_MSC_VER) && (_MSC_VER <= 1800)
   EXPECT_STREQ("9.27400999e-024 m^2 A", output.c_str());
@@ -1496,7 +1497,7 @@ TEST_F(UnitContainer, fmtlib) {
 #endif
 
   testing::internal::CaptureStdout();
-  fmt::print("{:.7}", constants::sigma);
+  wpi::print("{:.7}", constants::sigma);
   output = testing::internal::GetCapturedStdout();
 #if defined(_MSC_VER) && (_MSC_VER <= 1800)
   EXPECT_STREQ("5.670367e-008 kg s^-3 K^-4", output.c_str());

wpimath/src/test/native/cpp/estimator/DifferentialDrivePoseEstimatorTest.cpp

@@ -8,6 +8,7 @@
 #include <utility>
 
 #include <gtest/gtest.h>
+#include <wpi/print.h>
 
 #include "frc/StateSpaceUtil.h"
 #include "frc/estimator/DifferentialDrivePoseEstimator.h"
@@ -50,7 +51,7 @@ void testFollowTrajectory(
   double errorSum = 0;
 
   if (debug) {
-    fmt::print(
+    wpi::print(
         "time, est_x, est_y, est_theta, true_x, true_y, true_theta, left, "
         "right\n");
   }
@@ -95,7 +96,7 @@ void testFollowTrajectory(
         leftDistance, rightDistance);
 
     if (debug) {
-      fmt::print(
+      wpi::print(
           "{}, {}, {}, {}, {}, {}, {}, {}, {}\n", t.value(), xhat.X().value(),
           xhat.Y().value(), xhat.Rotation().Radians().value(),
           groundTruthState.pose.X().value(), groundTruthState.pose.Y().value(),
@@ -116,14 +117,14 @@ void testFollowTrajectory(
   }
 
   if (debug) {
-    fmt::print("apply_time, measured_time, vision_x, vision_y, vision_theta\n");
+    wpi::print("apply_time, measured_time, vision_x, vision_y, vision_theta\n");
 
     units::second_t apply_time;
     units::second_t measure_time;
     frc::Pose2d vision_pose;
     for (auto record : visionLog) {
       std::tie(apply_time, measure_time, vision_pose) = record;
-      fmt::print("{}, {}, {}, {}, {}\n", apply_time.value(),
+      wpi::print("{}, {}, {}, {}, {}\n", apply_time.value(),
                  measure_time.value(), vision_pose.X().value(),
                  vision_pose.Y().value(),
                  vision_pose.Rotation().Radians().value());

wpimath/src/test/native/cpp/estimator/MecanumDrivePoseEstimatorTest.cpp

@@ -7,6 +7,7 @@
 #include <tuple>
 
 #include <gtest/gtest.h>
+#include <wpi/print.h>
 
 #include "frc/estimator/MecanumDrivePoseEstimator.h"
 #include "frc/geometry/Pose2d.h"
@@ -42,7 +43,7 @@ void testFollowTrajectory(
   double errorSum = 0;
 
   if (debug) {
-    fmt::print("time, est_x, est_y, est_theta, true_x, true_y, true_theta\n");
+    wpi::print("time, est_x, est_y, est_theta, true_x, true_y, true_theta\n");
   }
 
   while (t < trajectory.TotalTime()) {
@@ -87,7 +88,7 @@ void testFollowTrajectory(
         wheelPositions);
 
     if (debug) {
-      fmt::print("{}, {}, {}, {}, {}, {}, {}\n", t.value(), xhat.X().value(),
+      wpi::print("{}, {}, {}, {}, {}, {}, {}\n", t.value(), xhat.X().value(),
                  xhat.Y().value(), xhat.Rotation().Radians().value(),
                  groundTruthState.pose.X().value(),
                  groundTruthState.pose.Y().value(),
@@ -107,14 +108,14 @@ void testFollowTrajectory(
   }
 
   if (debug) {
-    fmt::print("apply_time, measured_time, vision_x, vision_y, vision_theta\n");
+    wpi::print("apply_time, measured_time, vision_x, vision_y, vision_theta\n");
 
     units::second_t apply_time;
     units::second_t measure_time;
     frc::Pose2d vision_pose;
     for (auto record : visionLog) {
       std::tie(apply_time, measure_time, vision_pose) = record;
-      fmt::print("{}, {}, {}, {}, {}\n", apply_time.value(),
+      wpi::print("{}, {}, {}, {}, {}\n", apply_time.value(),
                  measure_time.value(), vision_pose.X().value(),
                  vision_pose.Y().value(),
                  vision_pose.Rotation().Radians().value());

wpimath/src/test/native/cpp/estimator/SwerveDrivePoseEstimatorTest.cpp

@@ -9,6 +9,7 @@
 
 #include <fmt/format.h>
 #include <gtest/gtest.h>
+#include <wpi/print.h>
 #include <wpi/timestamp.h>
 
 #include "frc/estimator/SwerveDrivePoseEstimator.h"
@@ -45,7 +46,7 @@ void testFollowTrajectory(
   double errorSum = 0;
 
   if (debug) {
-    fmt::print("time, est_x, est_y, est_theta, true_x, true_y, true_theta\n");
+    wpi::print("time, est_x, est_y, est_theta, true_x, true_y, true_theta\n");
   }
 
   while (t < trajectory.TotalTime()) {
@@ -90,7 +91,7 @@ void testFollowTrajectory(
         positions);
 
     if (debug) {
-      fmt::print("{}, {}, {}, {}, {}, {}, {}\n", t.value(), xhat.X().value(),
+      wpi::print("{}, {}, {}, {}, {}, {}, {}\n", t.value(), xhat.X().value(),
                  xhat.Y().value(), xhat.Rotation().Radians().value(),
                  groundTruthState.pose.X().value(),
                  groundTruthState.pose.Y().value(),
@@ -110,14 +111,14 @@ void testFollowTrajectory(
   }
 
   if (debug) {
-    fmt::print("apply_time, measured_time, vision_x, vision_y, vision_theta\n");
+    wpi::print("apply_time, measured_time, vision_x, vision_y, vision_theta\n");
 
     units::second_t apply_time;
     units::second_t measure_time;
     frc::Pose2d vision_pose;
     for (auto record : visionLog) {
       std::tie(apply_time, measure_time, vision_pose) = record;
-      fmt::print("{}, {}, {}, {}, {}\n", apply_time.value(),
+      wpi::print("{}, {}, {}, {}, {}\n", apply_time.value(),
                  measure_time.value(), vision_pose.X().value(),
                  vision_pose.Y().value(),
                  vision_pose.Rotation().Radians().value());

wpinet/examples/dsclient/dsclient.cpp

@@ -4,8 +4,8 @@
 
 #include <cstdio>
 
-#include <fmt/format.h>
 #include <wpi/Logger.h>
+#include <wpi/print.h>
 
 #include "wpinet/DsClient.h"
 #include "wpinet/EventLoopRunner.h"
@@ -27,7 +27,7 @@ int main() {
   loop.ExecAsync([&](uv::Loop& loop) {
     client = wpi::DsClient::Create(loop, logger);
     client->setIp.connect(
-        [](std::string_view ip) { fmt::print("got IP: {}\n", ip); });
+        [](std::string_view ip) { wpi::print("got IP: {}\n", ip); });
     client->clearIp.connect([] { std::fputs("cleared IP\n", stdout); });
   });
 

wpinet/examples/webserver/webserver.cpp

@@ -4,7 +4,7 @@
 
 #include <cstdio>
 
-#include <fmt/format.h>
+#include <wpi/print.h>
 
 #include "wpinet/EventLoopRunner.h"
 #include "wpinet/HttpServerConnection.h"
@@ -24,7 +24,7 @@ class MyHttpServerConnection : public wpi::HttpServerConnection {
 };
 
 void MyHttpServerConnection::ProcessRequest() {
-  fmt::print(stderr, "HTTP request: '{}'\n", m_request.GetUrl());
+  wpi::print(stderr, "HTTP request: '{}'\n", m_request.GetUrl());
   wpi::UrlParser url{m_request.GetUrl(),
                      m_request.GetMethod() == wpi::HTTP_CONNECT};
   if (!url.IsValid()) {
@@ -37,13 +37,13 @@ void MyHttpServerConnection::ProcessRequest() {
   if (url.HasPath()) {
     path = url.GetPath();
   }
-  fmt::print(stderr, "path: \"{}\"\n", path);
+  wpi::print(stderr, "path: \"{}\"\n", path);
 
   std::string_view query;
   if (url.HasQuery()) {
     query = url.GetQuery();
   }
-  fmt::print(stderr, "query: \"{}\"\n", query);
+  wpi::print(stderr, "query: \"{}\"\n", query);
 
   const bool isGET = m_request.GetMethod() == wpi::HTTP_GET;
   if (isGET && path == "/") {

wpinet/src/dev/native/cpp/main.cpp

@@ -2,10 +2,10 @@
 // Open Source Software; you can modify and/or share it under the terms of
 // the WPILib BSD license file in the root directory of this project.
 
-#include <fmt/core.h>
 #include <wpi/SmallString.h>
+#include <wpi/print.h>
 
 int main() {
   wpi::SmallString<128> v1("Hello");
-  fmt::print("{}\n", v1.str());
+  wpi::print("{}\n", v1.str());
 }

wpinet/src/main/native/cpp/HttpServerConnection.cpp

@@ -4,12 +4,12 @@
 
 #include "wpinet/HttpServerConnection.h"
 
-#include <fmt/format.h>
 #include <wpi/SmallString.h>
 #include <wpi/SmallVector.h>
 #include <wpi/SpanExtras.h>
 #include <wpi/StringExtras.h>
 #include <wpi/fmt/raw_ostream.h>
+#include <wpi/print.h>
 
 #include "wpinet/raw_uv_ostream.h"
 
@@ -65,7 +65,7 @@ void HttpServerConnection::BuildHeader(raw_ostream& os, int code,
                                        std::string_view contentType,
                                        uint64_t contentLength,
                                        std::string_view extra) {
-  fmt::print(os, "HTTP/{}.{} {} {}\r\n", m_request.GetMajor(),
+  wpi::print(os, "HTTP/{}.{} {} {}\r\n", m_request.GetMajor(),
              m_request.GetMinor(), code, codeText);
   if (contentLength == 0) {
     m_keepAlive = false;
@@ -76,7 +76,7 @@ void HttpServerConnection::BuildHeader(raw_ostream& os, int code,
   BuildCommonHeaders(os);
   os << "Content-Type: " << contentType << "\r\n";
   if (contentLength != 0) {
-    fmt::print(os, "Content-Length: {}\r\n", contentLength);
+    wpi::print(os, "Content-Length: {}\r\n", contentLength);
   }
   os << "Access-Control-Allow-Origin: *\r\nAccess-Control-Allow-Methods: *\r\n";
   if (!extra.empty()) {

wpinet/src/main/native/cpp/WebSocket.cpp

@@ -9,11 +9,11 @@
 #include <string>
 #include <string_view>
 
-#include <fmt/format.h>
 #include <wpi/Base64.h>
 #include <wpi/SmallString.h>
 #include <wpi/SmallVector.h>
 #include <wpi/StringExtras.h>
+#include <wpi/print.h>
 #include <wpi/raw_ostream.h>
 #include <wpi/sha1.h>
 
@@ -714,7 +714,7 @@ static void VerboseDebug(const WebSocket::Frame& frame) {
       str.append(std::string_view(d.base, d.len));
     }
 #endif
-    fmt::print("WS SendText({})\n", str.str());
+    wpi::print("WS SendText({})\n", str.str());
   } else if ((frame.opcode & 0x7f) == 0x02) {
     SmallString<128> str;
 #ifdef WPINET_WEBSOCKET_VERBOSE_DEBUG_CONTENT
@@ -725,7 +725,7 @@ static void VerboseDebug(const WebSocket::Frame& frame) {
       }
     }
 #endif
-    fmt::print("WS SendBinary({})\n", str.str());
+    wpi::print("WS SendBinary({})\n", str.str());
   } else {
     SmallString<128> str;
 #ifdef WPINET_WEBSOCKET_VERBOSE_DEBUG_CONTENT
@@ -736,7 +736,7 @@ static void VerboseDebug(const WebSocket::Frame& frame) {
       }
     }
 #endif
-    fmt::print("WS SendOp({}, {})\n", frame.opcode, str.str());
+    wpi::print("WS SendOp({}, {})\n", frame.opcode, str.str());
   }
 #endif
 }

wpinet/src/main/native/cpp/WebSocketServer.cpp

@@ -8,6 +8,7 @@
 
 #include <wpi/StringExtras.h>
 #include <wpi/fmt/raw_ostream.h>
+#include <wpi/print.h>
 
 #include "wpinet/raw_uv_ostream.h"
 #include "wpinet/uv/Buffer.h"
@@ -158,7 +159,7 @@ void WebSocketServer::Abort(uint16_t code, std::string_view reason) {
   raw_uv_ostream os{bufs, 1024};
 
   // Handle unsupported version
-  fmt::print(os, "HTTP/1.1 {} {}\r\n", code, reason);
+  wpi::print(os, "HTTP/1.1 {} {}\r\n", code, reason);
   if (code == 426) {
     os << "Upgrade: WebSocket\r\n";
   }

wpinet/src/netconsoleServer/native/cpp/main.cpp

@@ -15,6 +15,7 @@
 #include <wpi/SmallVector.h>
 #include <wpi/StringExtras.h>
 #include <wpi/bit.h>
+#include <wpi/print.h>
 #include <wpi/timestamp.h>
 
 #include "wpinet/raw_uv_ostream.h"
@@ -153,7 +154,7 @@ int main(int argc, char* argv[]) {
       useUdp = true;
       broadcastUdp = true;
     } else {
-      fmt::print(stderr, "unrecognized command line option {}\n",
+      wpi::print(stderr, "unrecognized command line option {}\n",
                  argv[programArgc]);
       err = true;
     }
@@ -174,7 +175,7 @@ int main(int argc, char* argv[]) {
 
   auto loop = uv::Loop::Create();
   loop->error.connect(
-      [](uv::Error err) { fmt::print(stderr, "uv ERROR: {}\n", err.str()); });
+      [](uv::Error err) { wpi::print(stderr, "uv ERROR: {}\n", err.str()); });
 
   // create pipes to communicate with child
   auto stdinPipe = uv::Pipe::Create(loop);

wpinet/src/netconsoleTee/native/cpp/main.cpp

@@ -9,6 +9,7 @@
 #include <wpi/SmallVector.h>
 #include <wpi/StringExtras.h>
 #include <wpi/bit.h>
+#include <wpi/print.h>
 #include <wpi/timestamp.h>
 
 #include "wpinet/raw_uv_ostream.h"
@@ -155,7 +156,7 @@ int main(int argc, char* argv[]) {
         port = portValue.value();
       }
     } else {
-      fmt::print(stderr, "unrecognized command line option {}\n", argv[arg]);
+      wpi::print(stderr, "unrecognized command line option {}\n", argv[arg]);
       err = true;
     }
     ++arg;
@@ -174,7 +175,7 @@ int main(int argc, char* argv[]) {
 
   auto loop = uv::Loop::Create();
   loop->error.connect(
-      [](uv::Error err) { fmt::print(stderr, "uv ERROR: {}\n", err.str()); });
+      [](uv::Error err) { wpi::print(stderr, "uv ERROR: {}\n", err.str()); });
 
   // create ttys
   auto stdinTty = uv::Tty::Create(loop, 0, true);

wpiutil/examples/printlog/printlog.cpp

@@ -10,20 +10,21 @@
 #include "wpi/DataLogReader.h"
 #include "wpi/DenseMap.h"
 #include "wpi/MemoryBuffer.h"
+#include "wpi/print.h"
 
 int main(int argc, const char** argv) {
   if (argc != 2) {
-    fmt::print(stderr, "Usage: printlog <file>\n");
+    wpi::print(stderr, "Usage: printlog <file>\n");
     return EXIT_FAILURE;
   }
   std::error_code ec;
   wpi::log::DataLogReader reader{wpi::MemoryBuffer::GetFile(argv[1], ec)};
   if (ec) {
-    fmt::print(stderr, "could not open file: {}\n", ec.message());
+    wpi::print(stderr, "could not open file: {}\n", ec.message());
     return EXIT_FAILURE;
   }
   if (!reader) {
-    fmt::print(stderr, "not a log file\n");
+    wpi::print(stderr, "not a log file\n");
     return EXIT_FAILURE;
   }
 
@@ -32,54 +33,54 @@ int main(int argc, const char** argv) {
     if (record.IsStart()) {
       wpi::log::StartRecordData data;
       if (record.GetStartData(&data)) {
-        fmt::print("Start({}, name='{}', type='{}', metadata='{}') [{}]\n",
+        wpi::print("Start({}, name='{}', type='{}', metadata='{}') [{}]\n",
                    data.entry, data.name, data.type, data.metadata,
                    record.GetTimestamp() / 1000000.0);
         if (entries.find(data.entry) != entries.end()) {
-          fmt::print("...DUPLICATE entry ID, overriding\n");
+          wpi::print("...DUPLICATE entry ID, overriding\n");
         }
         entries[data.entry] = data;
       } else {
-        fmt::print("Start(INVALID)\n");
+        wpi::print("Start(INVALID)\n");
       }
     } else if (record.IsFinish()) {
       int entry;
       if (record.GetFinishEntry(&entry)) {
-        fmt::print("Finish({}) [{}]\n", entry,
+        wpi::print("Finish({}) [{}]\n", entry,
                    record.GetTimestamp() / 1000000.0);
         auto it = entries.find(entry);
         if (it == entries.end()) {
-          fmt::print("...ID not found\n");
+          wpi::print("...ID not found\n");
         } else {
           entries.erase(it);
         }
       } else {
-        fmt::print("Finish(INVALID)\n");
+        wpi::print("Finish(INVALID)\n");
       }
     } else if (record.IsSetMetadata()) {
       wpi::log::MetadataRecordData data;
       if (record.GetSetMetadataData(&data)) {
-        fmt::print("SetMetadata({}, '{}') [{}]\n", data.entry, data.metadata,
+        wpi::print("SetMetadata({}, '{}') [{}]\n", data.entry, data.metadata,
                    record.GetTimestamp() / 1000000.0);
         auto it = entries.find(data.entry);
         if (it == entries.end()) {
-          fmt::print("...ID not found\n");
+          wpi::print("...ID not found\n");
         } else {
           it->second.metadata = data.metadata;
         }
       } else {
-        fmt::print("SetMetadata(INVALID)\n");
+        wpi::print("SetMetadata(INVALID)\n");
       }
     } else if (record.IsControl()) {
-      fmt::print("Unrecognized control record\n");
+      wpi::print("Unrecognized control record\n");
     } else {
-      fmt::print("Data({}, size={}) ", record.GetEntry(), record.GetSize());
+      wpi::print("Data({}, size={}) ", record.GetEntry(), record.GetSize());
       auto entry = entries.find(record.GetEntry());
       if (entry == entries.end()) {
-        fmt::print("<ID not found>\n");
+        wpi::print("<ID not found>\n");
         continue;
       }
-      fmt::print("<name='{}', type='{}'> [{}]\n", entry->second.name,
+      wpi::print("<name='{}', type='{}'> [{}]\n", entry->second.name,
                  entry->second.type, record.GetTimestamp() / 1000000.0);
 
       // handle systemTime specially
@@ -87,10 +88,10 @@ int main(int argc, const char** argv) {
         int64_t val;
         if (record.GetInteger(&val)) {
           std::time_t timeval = val / 1000000;
-          fmt::print("  {:%Y-%m-%d %H:%M:%S}.{:06}\n",
+          wpi::print("  {:%Y-%m-%d %H:%M:%S}.{:06}\n",
                      *std::localtime(&timeval), val % 1000000);
         } else {
-          fmt::print("  invalid\n");
+          wpi::print("  invalid\n");
         }
         continue;
       }
@@ -98,63 +99,63 @@ int main(int argc, const char** argv) {
       if (entry->second.type == "double") {
         double val;
         if (record.GetDouble(&val)) {
-          fmt::print("  {}\n", val);
+          wpi::print("  {}\n", val);
         } else {
-          fmt::print("  invalid\n");
+          wpi::print("  invalid\n");
         }
       } else if (entry->second.type == "int64") {
         int64_t val;
         if (record.GetInteger(&val)) {
-          fmt::print("  {}\n", val);
+          wpi::print("  {}\n", val);
         } else {
-          fmt::print("  invalid\n");
+          wpi::print("  invalid\n");
         }
       } else if (entry->second.type == "string" ||
                  entry->second.type == "json") {
         std::string_view val;
         record.GetString(&val);
-        fmt::print("  '{}'\n", val);
+        wpi::print("  '{}'\n", val);
       } else if (entry->second.type == "boolean") {
         bool val;
         if (record.GetBoolean(&val)) {
-          fmt::print("  {}\n", val);
+          wpi::print("  {}\n", val);
         } else {
-          fmt::print("  invalid\n");
+          wpi::print("  invalid\n");
         }
       } else if (entry->second.type == "boolean[]") {
         std::vector<int> val;
         if (record.GetBooleanArray(&val)) {
-          fmt::print("  {}\n", fmt::join(val, ", "));
+          wpi::print("  {}\n", fmt::join(val, ", "));
         } else {
-          fmt::print("  invalid\n");
+          wpi::print("  invalid\n");
         }
       } else if (entry->second.type == "double[]") {
         std::vector<double> val;
         if (record.GetDoubleArray(&val)) {
-          fmt::print("  {}\n", fmt::join(val, ", "));
+          wpi::print("  {}\n", fmt::join(val, ", "));
         } else {
-          fmt::print("  invalid\n");
+          wpi::print("  invalid\n");
         }
       } else if (entry->second.type == "float[]") {
         std::vector<float> val;
         if (record.GetFloatArray(&val)) {
-          fmt::print("  {}\n", fmt::join(val, ", "));
+          wpi::print("  {}\n", fmt::join(val, ", "));
         } else {
-          fmt::print("  invalid\n");
+          wpi::print("  invalid\n");
         }
       } else if (entry->second.type == "int64[]") {
         std::vector<int64_t> val;
         if (record.GetIntegerArray(&val)) {
-          fmt::print("  {}\n", fmt::join(val, ", "));
+          wpi::print("  {}\n", fmt::join(val, ", "));
         } else {
-          fmt::print("  invalid\n");
+          wpi::print("  invalid\n");
         }
       } else if (entry->second.type == "string[]") {
         std::vector<std::string_view> val;
         if (record.GetStringArray(&val)) {
-          fmt::print("  {}\n", fmt::join(val, ", "));
+          wpi::print("  {}\n", fmt::join(val, ", "));
         } else {
-          fmt::print("  invalid\n");
+          wpi::print("  invalid\n");
         }
       }
     }

wpiutil/examples/writelog/writelog.cpp

@@ -8,9 +8,8 @@
 #include <string>
 #include <vector>
 
-#include <fmt/format.h>
-
 #include "wpi/DataLog.h"
+#include "wpi/print.h"
 
 int main(int argc, char** argv) {
   using std::chrono::duration_cast;
@@ -66,7 +65,7 @@ int main(int argc, char** argv) {
 
   for (const auto& [name, fn] : testVec) {
     auto resVec = std::vector<microseconds::rep>();
-    fmt::print("{}: ", name);
+    wpi::print("{}: ", name);
 
     for (int i = 0; i < kNumRuns; ++i) {
       auto start = high_resolution_clock::now();
@@ -75,7 +74,7 @@ int main(int argc, char** argv) {
       resVec.push_back(duration_cast<microseconds>(stop - start).count());
     }
 
-    fmt::print("{}us\n",
+    wpi::print("{}us\n",
                std::accumulate(resVec.begin(), resVec.end(), 0) / kNumRuns);
   }
 

wpiutil/src/dev/native/cpp/main.cpp

@@ -2,11 +2,11 @@
 // Open Source Software; you can modify and/or share it under the terms of
 // the WPILib BSD license file in the root directory of this project.
 
-#include <fmt/core.h>
+#include <wpi/print.h>
 
 #include "wpi/SmallString.h"
 
 int main() {
   wpi::SmallString<128> v1("Hello");
-  fmt::print("{}\n", v1.str());
+  wpi::print("{}\n", v1.str());
 }

wpiutil/src/main/native/cpp/DataLog.cpp

@@ -27,13 +27,12 @@
 #include <random>
 #include <vector>
 
-#include <fmt/format.h>
-
 #include "wpi/Endian.h"
 #include "wpi/Logger.h"
 #include "wpi/MathExtras.h"
 #include "wpi/SmallString.h"
 #include "wpi/fs.h"
+#include "wpi/print.h"
 #include "wpi/timestamp.h"
 
 using namespace wpi::log;
@@ -142,9 +141,9 @@ class DataLog::Buffer {
 static void DefaultLog(unsigned int level, const char* file, unsigned int line,
                        const char* msg) {
   if (level > wpi::WPI_LOG_INFO) {
-    fmt::print(stderr, "DataLog: {}\n", msg);
+    wpi::print(stderr, "DataLog: {}\n", msg);
   } else if (level == wpi::WPI_LOG_INFO) {
-    fmt::print("DataLog: {}\n", msg);
+    wpi::print("DataLog: {}\n", msg);
   }
 }
 

wpiutil/src/main/native/cpp/jni/WPIUtilJNI.cpp

@@ -6,12 +6,11 @@
 
 #include <jni.h>
 
-#include <fmt/format.h>
-
 #include "edu_wpi_first_util_WPIUtilJNI.h"
 #include "wpi/RawFrame.h"
 #include "wpi/Synchronization.h"
 #include "wpi/jni_util.h"
+#include "wpi/print.h"
 #include "wpi/timestamp.h"
 
 using namespace wpi::java;
@@ -80,7 +79,7 @@ JNIEXPORT void JNICALL
 Java_edu_wpi_first_util_WPIUtilJNI_writeStderr
   (JNIEnv* env, jclass, jstring str)
 {
-  fmt::print(stderr, "{}", JStringRef{env, str}.str());
+  wpi::print(stderr, "{}", JStringRef{env, str}.str());
 }
 
 /*
@@ -93,7 +92,7 @@ Java_edu_wpi_first_util_WPIUtilJNI_enableMockTime
   (JNIEnv*, jclass)
 {
 #ifdef __FRC_ROBORIO__
-  fmt::print(stderr, "WPIUtil: Mocking time is not available on the Rio\n");
+  wpi::print(stderr, "WPIUtil: Mocking time is not available on the Rio\n");
 #else
   mockTimeEnabled = true;
   wpi::SetNowImpl([] { return mockNow; });

wpiutil/src/main/native/cpp/timestamp.cpp

@@ -35,7 +35,7 @@ using namespace nRoboRIO_FPGANamespace;
 
 #include <cstdio>
 
-#include <fmt/format.h>
+#include "wpi/print.h"
 
 #ifdef __FRC_ROBORIO__
 namespace {
@@ -68,7 +68,7 @@ struct HMBLowLevel {
     int32_t status = 0;
     niFpga.reset(dlopen("libNiFpga.so", RTLD_LAZY));
     if (!niFpga) {
-      fmt::print(stderr, "Could not open libNiFpga.so\n");
+      wpi::print(stderr, "Could not open libNiFpga.so\n");
       return false;
     }
     NiFpga_OpenHmbFunc openHmb = reinterpret_cast<NiFpga_OpenHmbFunc>(
@@ -84,14 +84,14 @@ struct HMBLowLevel {
         dlsym(niFpga.get(), "NiFpgaDll_WriteU32"));
     if (openHmb == nullptr || closeHmb == nullptr || findRegister == nullptr ||
         writeU32 == nullptr || readU32 == nullptr) {
-      fmt::print(stderr, "Could not find HMB symbols in libNiFpga.so\n");
+      wpi::print(stderr, "Could not find HMB symbols in libNiFpga.so\n");
       niFpga = nullptr;
       return false;
     }
     uint32_t hmbConfigRegister = 0;
     status = findRegister(session, "HMB.Config", &hmbConfigRegister);
     if (status != 0) {
-      fmt::print(stderr, "Failed to find HMB.Config register, status code {}\n",
+      wpi::print(stderr, "Failed to find HMB.Config register, status code {}\n",
                  status);
       closeHmb = nullptr;
       niFpga = nullptr;
@@ -102,7 +102,7 @@ struct HMBLowLevel {
         openHmb(session, hmbName, &hmbBufferSize,
                 reinterpret_cast<void**>(const_cast<uint32_t**>(&hmbBuffer)));
     if (status != 0) {
-      fmt::print(stderr, "Failed to open HMB, status code {}\n", status);
+      wpi::print(stderr, "Failed to open HMB, status code {}\n", status);
       closeHmb = nullptr;
       niFpga = nullptr;
       return false;
@@ -273,7 +273,7 @@ uint64_t wpi::Now() {
     if (nowUseDefaultOnFailure.test()) {
       return timestamp() - offset_val;
     } else {
-      fmt::print(stderr,
+      wpi::print(stderr,
                  "FPGA not yet configured in wpi::Now(). This is a fatal "
                  "error. The process is being terminated.\n");
       std::fflush(stderr);

wpiutil/src/main/native/include/wpi/fmt/raw_ostream.h

@@ -9,12 +9,12 @@
 
 #include "wpi/raw_ostream.h"
 
-FMT_BEGIN_NAMESPACE
+namespace wpi {
 
-inline void vprint(wpi::raw_ostream& os, string_view format_str,
+inline void vprint(wpi::raw_ostream& os, fmt::string_view format_str,
                    fmt::format_args args) {
-  memory_buffer buffer;
-  detail::vformat_to(buffer, format_str, args);
+  fmt::memory_buffer buffer;
+  fmt::detail::vformat_to(buffer, format_str, args);
   os.write(buffer.data(), buffer.size());
 }
 
@@ -26,6 +26,6 @@ void print(wpi::raw_ostream& os, const S& format_str, Args&&... args) {
   vprint(os, format_str, fmt::make_format_args(args...));
 }
 
-FMT_END_NAMESPACE
+}  // namespace wpi
 
 #endif  // WPIUTIL_WPI_FMT_RAW_OSTREAM_H_

wpiutil/src/main/native/include/wpi/jni_util.h

@@ -15,14 +15,13 @@
 #include <utility>
 #include <vector>
 
-#include <fmt/core.h>
-
 #include "wpi/ConvertUTF.h"
 #include "wpi/SafeThread.h"
 #include "wpi/SmallString.h"
 #include "wpi/SmallVector.h"
 #include "wpi/StringExtras.h"
 #include "wpi/mutex.h"
+#include "wpi/print.h"
 #include "wpi/raw_ostream.h"
 
 /** Java Native Interface (JNI) utility functions */
@@ -160,7 +159,7 @@ class JStringRef {
         env->ReleaseStringCritical(str, chars);
       }
     } else {
-      fmt::print(stderr, "JStringRef was passed a null pointer at\n",
+      wpi::print(stderr, "JStringRef was passed a null pointer at\n",
                  GetJavaStackTrace(env));
     }
     // Ensure str is null-terminated.
@@ -283,7 +282,7 @@ class JSpanBase {
         m_elements{static_cast<std::remove_cv_t<T>*>(
             bb ? env->GetDirectBufferAddress(bb) : nullptr)} {
     if (!bb) {
-      fmt::print(stderr, "JSpan was passed a null pointer at\n",
+      wpi::print(stderr, "JSpan was passed a null pointer at\n",
                  GetJavaStackTrace(env));
     }
   }
@@ -302,7 +301,7 @@ class JSpanBase {
         m_elements = ArrHelper::GetArrayElements(env, jarr);
       }
     } else {
-      fmt::print(stderr, "JSpan was passed a null pointer at\n",
+      wpi::print(stderr, "JSpan was passed a null pointer at\n",
                  GetJavaStackTrace(env));
     }
   }

wpiutil/src/main/native/include/wpi/print.h

@@ -0,0 +1,58 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <system_error>
+#include <utility>
+
+#include <fmt/core.h>
+
+namespace wpi {
+
+/**
+ * Wrapper around fmt::print() that squelches write failure exceptions.
+ */
+template <typename... T>
+inline void print(fmt::format_string<T...> fmt, T&&... args) {
+  try {
+    fmt::print(fmt, std::forward<T>(args)...);
+  } catch (const std::system_error&) {
+  }
+}
+
+/**
+ * Wrapper around fmt::print() that squelches write failure exceptions.
+ */
+template <typename... T>
+inline void print(std::FILE* f, fmt::format_string<T...> fmt, T&&... args) {
+  try {
+    fmt::print(f, fmt, std::forward<T>(args)...);
+  } catch (const std::system_error&) {
+  }
+}
+
+/**
+ * Wrapper around fmt::println() that squelches write failure exceptions.
+ */
+template <typename... T>
+inline void println(fmt::format_string<T...> fmt, T&&... args) {
+  try {
+    fmt::println(fmt, std::forward<T>(args)...);
+  } catch (const std::system_error&) {
+  }
+}
+
+/**
+ * Wrapper around fmt::println() that squelches write failure exceptions.
+ */
+template <typename... T>
+inline void println(std::FILE* f, fmt::format_string<T...> fmt, T&&... args) {
+  try {
+    fmt::println(f, fmt, std::forward<T>(args)...);
+  } catch (const std::system_error&) {
+  }
+}
+
+}  // namespace wpi

wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/args.h

@@ -22,8 +22,9 @@ template <typename T> struct is_reference_wrapper : std::false_type {};
 template <typename T>
 struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
 
-template <typename T> const T& unwrap(const T& v) { return v; }
-template <typename T> const T& unwrap(const std::reference_wrapper<T>& v) {
+template <typename T> auto unwrap(const T& v) -> const T& { return v; }
+template <typename T>
+auto unwrap(const std::reference_wrapper<T>& v) -> const T& {
   return static_cast<const T&>(v);
 }
 
@@ -50,7 +51,7 @@ class dynamic_arg_list {
   std::unique_ptr<node<>> head_;
 
  public:
-  template <typename T, typename Arg> const T& push(const Arg& arg) {
+  template <typename T, typename Arg> auto push(const Arg& arg) -> const T& {
     auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
     auto& value = new_node->value;
     new_node->next = std::move(head_);
@@ -110,14 +111,14 @@ class dynamic_format_arg_store
 
   friend class basic_format_args<Context>;
 
-  unsigned long long get_types() const {
+  auto get_types() const -> unsigned long long {
     return detail::is_unpacked_bit | data_.size() |
            (named_info_.empty()
                 ? 0ULL
                 : static_cast<unsigned long long>(detail::has_named_args_bit));
   }
 
-  const basic_format_arg<Context>* data() const {
+  auto data() const -> const basic_format_arg<Context>* {
     return named_info_.empty() ? data_.data() : data_.data() + 1;
   }
 

wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/chrono.h

@@ -18,7 +18,7 @@
 #include <ostream>
 #include <type_traits>
 
-#include "format.h"
+#include "ostream.h"  // formatbuf
 
 FMT_BEGIN_NAMESPACE
 
@@ -72,7 +72,8 @@ template <typename To, typename From,
           FMT_ENABLE_IF(!std::is_same<From, To>::value &&
                         std::numeric_limits<From>::is_signed ==
                             std::numeric_limits<To>::is_signed)>
-FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
+FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)
+    -> To {
   ec = 0;
   using F = std::numeric_limits<From>;
   using T = std::numeric_limits<To>;
@@ -101,7 +102,8 @@ template <typename To, typename From,
           FMT_ENABLE_IF(!std::is_same<From, To>::value &&
                         std::numeric_limits<From>::is_signed !=
                             std::numeric_limits<To>::is_signed)>
-FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
+FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)
+    -> To {
   ec = 0;
   using F = std::numeric_limits<From>;
   using T = std::numeric_limits<To>;
@@ -133,7 +135,8 @@ FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
 
 template <typename To, typename From,
           FMT_ENABLE_IF(std::is_same<From, To>::value)>
-FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
+FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)
+    -> To {
   ec = 0;
   return from;
 }  // function
@@ -154,7 +157,7 @@ FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
 // clang-format on
 template <typename To, typename From,
           FMT_ENABLE_IF(!std::is_same<From, To>::value)>
-FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) {
+FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To {
   ec = 0;
   using T = std::numeric_limits<To>;
   static_assert(std::is_floating_point<From>::value, "From must be floating");
@@ -176,7 +179,7 @@ FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) {
 
 template <typename To, typename From,
           FMT_ENABLE_IF(std::is_same<From, To>::value)>
-FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) {
+FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To {
   ec = 0;
   static_assert(std::is_floating_point<From>::value, "From must be floating");
   return from;
@@ -188,8 +191,8 @@ FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) {
 template <typename To, typename FromRep, typename FromPeriod,
           FMT_ENABLE_IF(std::is_integral<FromRep>::value),
           FMT_ENABLE_IF(std::is_integral<typename To::rep>::value)>
-To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
-                      int& ec) {
+auto safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
+                        int& ec) -> To {
   using From = std::chrono::duration<FromRep, FromPeriod>;
   ec = 0;
   // the basic idea is that we need to convert from count() in the from type
@@ -240,8 +243,8 @@ To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
 template <typename To, typename FromRep, typename FromPeriod,
           FMT_ENABLE_IF(std::is_floating_point<FromRep>::value),
           FMT_ENABLE_IF(std::is_floating_point<typename To::rep>::value)>
-To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
-                      int& ec) {
+auto safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
+                        int& ec) -> To {
   using From = std::chrono::duration<FromRep, FromPeriod>;
   ec = 0;
   if (std::isnan(from.count())) {
@@ -321,12 +324,12 @@ To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
 
 namespace detail {
 template <typename T = void> struct null {};
-inline null<> localtime_r FMT_NOMACRO(...) { return null<>(); }
-inline null<> localtime_s(...) { return null<>(); }
-inline null<> gmtime_r(...) { return null<>(); }
-inline null<> gmtime_s(...) { return null<>(); }
+inline auto localtime_r FMT_NOMACRO(...) -> null<> { return null<>(); }
+inline auto localtime_s(...) -> null<> { return null<>(); }
+inline auto gmtime_r(...) -> null<> { return null<>(); }
+inline auto gmtime_s(...) -> null<> { return null<>(); }
 
-inline const std::locale& get_classic_locale() {
+inline auto get_classic_locale() -> const std::locale& {
   static const auto& locale = std::locale::classic();
   return locale;
 }
@@ -336,8 +339,6 @@ template <typename CodeUnit> struct codecvt_result {
   CodeUnit buf[max_size];
   CodeUnit* end;
 };
-template <typename CodeUnit>
-constexpr const size_t codecvt_result<CodeUnit>::max_size;
 
 template <typename CodeUnit>
 void write_codecvt(codecvt_result<CodeUnit>& out, string_view in_buf,
@@ -408,8 +409,7 @@ inline void do_write(buffer<Char>& buf, const std::tm& time,
   auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
   auto&& os = std::basic_ostream<Char>(&format_buf);
   os.imbue(loc);
-  using iterator = std::ostreambuf_iterator<Char>;
-  const auto& facet = std::use_facet<std::time_put<Char, iterator>>(loc);
+  const auto& facet = std::use_facet<std::time_put<Char>>(loc);
   auto end = facet.put(os, os, Char(' '), &time, format, modifier);
   if (end.failed()) FMT_THROW(format_error("failed to format time"));
 }
@@ -432,6 +432,51 @@ auto write(OutputIt out, const std::tm& time, const std::locale& loc,
   return write_encoded_tm_str(out, string_view(buf.data(), buf.size()), loc);
 }
 
+template <typename Rep1, typename Rep2>
+struct is_same_arithmetic_type
+    : public std::integral_constant<bool,
+                                    (std::is_integral<Rep1>::value &&
+                                     std::is_integral<Rep2>::value) ||
+                                        (std::is_floating_point<Rep1>::value &&
+                                         std::is_floating_point<Rep2>::value)> {
+};
+
+template <
+    typename To, typename FromRep, typename FromPeriod,
+    FMT_ENABLE_IF(is_same_arithmetic_type<FromRep, typename To::rep>::value)>
+auto fmt_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) -> To {
+#if FMT_SAFE_DURATION_CAST
+  // Throwing version of safe_duration_cast is only available for
+  // integer to integer or float to float casts.
+  int ec;
+  To to = safe_duration_cast::safe_duration_cast<To>(from, ec);
+  if (ec) FMT_THROW(format_error("cannot format duration"));
+  return to;
+#else
+  // Standard duration cast, may overflow.
+  return std::chrono::duration_cast<To>(from);
+#endif
+}
+
+template <
+    typename To, typename FromRep, typename FromPeriod,
+    FMT_ENABLE_IF(!is_same_arithmetic_type<FromRep, typename To::rep>::value)>
+auto fmt_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) -> To {
+  // Mixed integer <-> float cast is not supported by safe_duration_cast.
+  return std::chrono::duration_cast<To>(from);
+}
+
+template <typename Duration>
+auto to_time_t(
+    std::chrono::time_point<std::chrono::system_clock, Duration> time_point)
+    -> std::time_t {
+  // Cannot use std::chrono::system_clock::to_time_t since this would first
+  // require a cast to std::chrono::system_clock::time_point, which could
+  // overflow.
+  return fmt_duration_cast<std::chrono::duration<std::time_t>>(
+             time_point.time_since_epoch())
+      .count();
+}
 }  // namespace detail
 
 FMT_BEGIN_EXPORT
@@ -441,29 +486,29 @@ FMT_BEGIN_EXPORT
   expressed in local time. Unlike ``std::localtime``, this function is
   thread-safe on most platforms.
  */
-inline std::tm localtime(std::time_t time) {
+inline auto localtime(std::time_t time) -> std::tm {
   struct dispatcher {
     std::time_t time_;
     std::tm tm_;
 
     dispatcher(std::time_t t) : time_(t) {}
 
-    bool run() {
+    auto run() -> bool {
       using namespace fmt::detail;
       return handle(localtime_r(&time_, &tm_));
     }
 
-    bool handle(std::tm* tm) { return tm != nullptr; }
+    auto handle(std::tm* tm) -> bool { return tm != nullptr; }
 
-    bool handle(detail::null<>) {
+    auto handle(detail::null<>) -> bool {
       using namespace fmt::detail;
       return fallback(localtime_s(&tm_, &time_));
     }
 
-    bool fallback(int res) { return res == 0; }
+    auto fallback(int res) -> bool { return res == 0; }
 
 #if !FMT_MSC_VERSION
-    bool fallback(detail::null<>) {
+    auto fallback(detail::null<>) -> bool {
       using namespace fmt::detail;
       std::tm* tm = std::localtime(&time_);
       if (tm) tm_ = *tm;
@@ -480,8 +525,8 @@ inline std::tm localtime(std::time_t time) {
 #if FMT_USE_LOCAL_TIME
 template <typename Duration>
 inline auto localtime(std::chrono::local_time<Duration> time) -> std::tm {
-  return localtime(std::chrono::system_clock::to_time_t(
-      std::chrono::current_zone()->to_sys(time)));
+  return localtime(
+      detail::to_time_t(std::chrono::current_zone()->to_sys(time)));
 }
 #endif
 
@@ -490,29 +535,29 @@ inline auto localtime(std::chrono::local_time<Duration> time) -> std::tm {
   expressed in Coordinated Universal Time (UTC). Unlike ``std::gmtime``, this
   function is thread-safe on most platforms.
  */
-inline std::tm gmtime(std::time_t time) {
+inline auto gmtime(std::time_t time) -> std::tm {
   struct dispatcher {
     std::time_t time_;
     std::tm tm_;
 
     dispatcher(std::time_t t) : time_(t) {}
 
-    bool run() {
+    auto run() -> bool {
       using namespace fmt::detail;
       return handle(gmtime_r(&time_, &tm_));
     }
 
-    bool handle(std::tm* tm) { return tm != nullptr; }
+    auto handle(std::tm* tm) -> bool { return tm != nullptr; }
 
-    bool handle(detail::null<>) {
+    auto handle(detail::null<>) -> bool {
       using namespace fmt::detail;
       return fallback(gmtime_s(&tm_, &time_));
     }
 
-    bool fallback(int res) { return res == 0; }
+    auto fallback(int res) -> bool { return res == 0; }
 
 #if !FMT_MSC_VERSION
-    bool fallback(detail::null<>) {
+    auto fallback(detail::null<>) -> bool {
       std::tm* tm = std::gmtime(&time_);
       if (tm) tm_ = *tm;
       return tm != nullptr;
@@ -525,9 +570,11 @@ inline std::tm gmtime(std::time_t time) {
   return gt.tm_;
 }
 
-inline std::tm gmtime(
-    std::chrono::time_point<std::chrono::system_clock> time_point) {
-  return gmtime(std::chrono::system_clock::to_time_t(time_point));
+template <typename Duration>
+inline auto gmtime(
+    std::chrono::time_point<std::chrono::system_clock, Duration> time_point)
+    -> std::tm {
+  return gmtime(detail::to_time_t(time_point));
 }
 
 namespace detail {
@@ -566,7 +613,8 @@ inline void write_digit2_separated(char* buf, unsigned a, unsigned b,
   }
 }
 
-template <typename Period> FMT_CONSTEXPR inline const char* get_units() {
+template <typename Period>
+FMT_CONSTEXPR inline auto get_units() -> const char* {
   if (std::is_same<Period, std::atto>::value) return "as";
   if (std::is_same<Period, std::femto>::value) return "fs";
   if (std::is_same<Period, std::pico>::value) return "ps";
@@ -584,8 +632,9 @@ template <typename Period> FMT_CONSTEXPR inline const char* get_units() {
   if (std::is_same<Period, std::tera>::value) return "Ts";
   if (std::is_same<Period, std::peta>::value) return "Ps";
   if (std::is_same<Period, std::exa>::value) return "Es";
-  if (std::is_same<Period, std::ratio<60>>::value) return "m";
+  if (std::is_same<Period, std::ratio<60>>::value) return "min";
   if (std::is_same<Period, std::ratio<3600>>::value) return "h";
+  if (std::is_same<Period, std::ratio<86400>>::value) return "d";
   return nullptr;
 }
 
@@ -621,9 +670,8 @@ auto write_padding(OutputIt out, pad_type pad) -> OutputIt {
 
 // Parses a put_time-like format string and invokes handler actions.
 template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin,
-                                              const Char* end,
-                                              Handler&& handler) {
+FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end,
+                                       Handler&& handler) -> const Char* {
   if (begin == end || *begin == '}') return begin;
   if (*begin != '%') FMT_THROW(format_error("invalid format"));
   auto ptr = begin;
@@ -954,25 +1002,25 @@ struct tm_format_checker : null_chrono_spec_handler<tm_format_checker> {
   FMT_CONSTEXPR void on_tz_name() {}
 };
 
-inline const char* tm_wday_full_name(int wday) {
+inline auto tm_wday_full_name(int wday) -> const char* {
   static constexpr const char* full_name_list[] = {
       "Sunday",   "Monday", "Tuesday", "Wednesday",
       "Thursday", "Friday", "Saturday"};
   return wday >= 0 && wday <= 6 ? full_name_list[wday] : "?";
 }
-inline const char* tm_wday_short_name(int wday) {
+inline auto tm_wday_short_name(int wday) -> const char* {
   static constexpr const char* short_name_list[] = {"Sun", "Mon", "Tue", "Wed",
                                                     "Thu", "Fri", "Sat"};
   return wday >= 0 && wday <= 6 ? short_name_list[wday] : "???";
 }
 
-inline const char* tm_mon_full_name(int mon) {
+inline auto tm_mon_full_name(int mon) -> const char* {
   static constexpr const char* full_name_list[] = {
       "January", "February", "March",     "April",   "May",      "June",
       "July",    "August",   "September", "October", "November", "December"};
   return mon >= 0 && mon <= 11 ? full_name_list[mon] : "?";
 }
-inline const char* tm_mon_short_name(int mon) {
+inline auto tm_mon_short_name(int mon) -> const char* {
   static constexpr const char* short_name_list[] = {
       "Jan", "Feb", "Mar", "Apr", "May", "Jun",
       "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
@@ -1004,21 +1052,21 @@ inline void tzset_once() {
 
 // Converts value to Int and checks that it's in the range [0, upper).
 template <typename T, typename Int, FMT_ENABLE_IF(std::is_integral<T>::value)>
-inline Int to_nonnegative_int(T value, Int upper) {
-  FMT_ASSERT(std::is_unsigned<Int>::value ||
-                 (value >= 0 && to_unsigned(value) <= to_unsigned(upper)),
-             "invalid value");
-  (void)upper;
+inline auto to_nonnegative_int(T value, Int upper) -> Int {
+  if (!std::is_unsigned<Int>::value &&
+      (value < 0 || to_unsigned(value) > to_unsigned(upper))) {
+    FMT_THROW(fmt::format_error("chrono value is out of range"));
+  }
   return static_cast<Int>(value);
 }
 template <typename T, typename Int, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-inline Int to_nonnegative_int(T value, Int upper) {
+inline auto to_nonnegative_int(T value, Int upper) -> Int {
   if (value < 0 || value > static_cast<T>(upper))
     FMT_THROW(format_error("invalid value"));
   return static_cast<Int>(value);
 }
 
-constexpr long long pow10(std::uint32_t n) {
+constexpr auto pow10(std::uint32_t n) -> long long {
   return n == 0 ? 1 : 10 * pow10(n - 1);
 }
 
@@ -1052,13 +1100,12 @@ void write_fractional_seconds(OutputIt& out, Duration d, int precision = -1) {
                                 std::chrono::seconds::rep>::type,
       std::ratio<1, detail::pow10(num_fractional_digits)>>;
 
-  const auto fractional =
-      d - std::chrono::duration_cast<std::chrono::seconds>(d);
+  const auto fractional = d - fmt_duration_cast<std::chrono::seconds>(d);
   const auto subseconds =
       std::chrono::treat_as_floating_point<
           typename subsecond_precision::rep>::value
           ? fractional.count()
-          : std::chrono::duration_cast<subsecond_precision>(fractional).count();
+          : fmt_duration_cast<subsecond_precision>(fractional).count();
   auto n = static_cast<uint32_or_64_or_128_t<long long>>(subseconds);
   const int num_digits = detail::count_digits(n);
 
@@ -1109,11 +1156,11 @@ void write_floating_seconds(memory_buffer& buf, Duration duration,
       num_fractional_digits = 6;
   }
 
-  format_to(std::back_inserter(buf), FMT_STRING("{:.{}f}"),
-            std::fmod(val * static_cast<rep>(Duration::period::num) /
-                          static_cast<rep>(Duration::period::den),
-                      static_cast<rep>(60)),
-            num_fractional_digits);
+  fmt::format_to(std::back_inserter(buf), FMT_STRING("{:.{}f}"),
+                 std::fmod(val * static_cast<rep>(Duration::period::num) /
+                               static_cast<rep>(Duration::period::den),
+                           static_cast<rep>(60)),
+                 num_fractional_digits);
 }
 
 template <typename OutputIt, typename Char,
@@ -1174,8 +1221,7 @@ class tm_writer {
     return static_cast<int>(l);
   }
 
-  // Algorithm:
-  // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_the_week_number_from_a_month_and_day_of_the_month_or_ordinal_date
+  // Algorithm: https://en.wikipedia.org/wiki/ISO_week_date.
   auto iso_year_weeks(long long curr_year) const noexcept -> int {
     const auto prev_year = curr_year - 1;
     const auto curr_p =
@@ -1315,7 +1361,7 @@ class tm_writer {
         subsecs_(subsecs),
         tm_(tm) {}
 
-  OutputIt out() const { return out_; }
+  auto out() const -> OutputIt { return out_; }
 
   FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) {
     out_ = copy_str<Char>(begin, end, out_);
@@ -1579,6 +1625,7 @@ struct chrono_format_checker : null_chrono_spec_handler<chrono_format_checker> {
 
   template <typename Char>
   FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
+  FMT_CONSTEXPR void on_day_of_year() {}
   FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {}
   FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {}
   FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {}
@@ -1597,16 +1644,16 @@ struct chrono_format_checker : null_chrono_spec_handler<chrono_format_checker> {
 
 template <typename T,
           FMT_ENABLE_IF(std::is_integral<T>::value&& has_isfinite<T>::value)>
-inline bool isfinite(T) {
+inline auto isfinite(T) -> bool {
   return true;
 }
 
 template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-inline T mod(T x, int y) {
+inline auto mod(T x, int y) -> T {
   return x % static_cast<T>(y);
 }
 template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-inline T mod(T x, int y) {
+inline auto mod(T x, int y) -> T {
   return std::fmod(x, static_cast<T>(y));
 }
 
@@ -1621,49 +1668,38 @@ template <typename T> struct make_unsigned_or_unchanged<T, true> {
   using type = typename std::make_unsigned<T>::type;
 };
 
-#if FMT_SAFE_DURATION_CAST
-// throwing version of safe_duration_cast
-template <typename To, typename FromRep, typename FromPeriod>
-To fmt_safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) {
-  int ec;
-  To to = safe_duration_cast::safe_duration_cast<To>(from, ec);
-  if (ec) FMT_THROW(format_error("cannot format duration"));
-  return to;
-}
-#endif
-
 template <typename Rep, typename Period,
           FMT_ENABLE_IF(std::is_integral<Rep>::value)>
-inline std::chrono::duration<Rep, std::milli> get_milliseconds(
-    std::chrono::duration<Rep, Period> d) {
+inline auto get_milliseconds(std::chrono::duration<Rep, Period> d)
+    -> std::chrono::duration<Rep, std::milli> {
   // this may overflow and/or the result may not fit in the
   // target type.
 #if FMT_SAFE_DURATION_CAST
   using CommonSecondsType =
       typename std::common_type<decltype(d), std::chrono::seconds>::type;
-  const auto d_as_common = fmt_safe_duration_cast<CommonSecondsType>(d);
+  const auto d_as_common = fmt_duration_cast<CommonSecondsType>(d);
   const auto d_as_whole_seconds =
-      fmt_safe_duration_cast<std::chrono::seconds>(d_as_common);
+      fmt_duration_cast<std::chrono::seconds>(d_as_common);
   // this conversion should be nonproblematic
   const auto diff = d_as_common - d_as_whole_seconds;
   const auto ms =
-      fmt_safe_duration_cast<std::chrono::duration<Rep, std::milli>>(diff);
+      fmt_duration_cast<std::chrono::duration<Rep, std::milli>>(diff);
   return ms;
 #else
-  auto s = std::chrono::duration_cast<std::chrono::seconds>(d);
-  return std::chrono::duration_cast<std::chrono::milliseconds>(d - s);
+  auto s = fmt_duration_cast<std::chrono::seconds>(d);
+  return fmt_duration_cast<std::chrono::milliseconds>(d - s);
 #endif
 }
 
 template <typename Char, typename Rep, typename OutputIt,
           FMT_ENABLE_IF(std::is_integral<Rep>::value)>
-OutputIt format_duration_value(OutputIt out, Rep val, int) {
+auto format_duration_value(OutputIt out, Rep val, int) -> OutputIt {
   return write<Char>(out, val);
 }
 
 template <typename Char, typename Rep, typename OutputIt,
           FMT_ENABLE_IF(std::is_floating_point<Rep>::value)>
-OutputIt format_duration_value(OutputIt out, Rep val, int precision) {
+auto format_duration_value(OutputIt out, Rep val, int precision) -> OutputIt {
   auto specs = format_specs<Char>();
   specs.precision = precision;
   specs.type = precision >= 0 ? presentation_type::fixed_lower
@@ -1672,12 +1708,12 @@ OutputIt format_duration_value(OutputIt out, Rep val, int precision) {
 }
 
 template <typename Char, typename OutputIt>
-OutputIt copy_unit(string_view unit, OutputIt out, Char) {
+auto copy_unit(string_view unit, OutputIt out, Char) -> OutputIt {
   return std::copy(unit.begin(), unit.end(), out);
 }
 
 template <typename OutputIt>
-OutputIt copy_unit(string_view unit, OutputIt out, wchar_t) {
+auto copy_unit(string_view unit, OutputIt out, wchar_t) -> OutputIt {
   // This works when wchar_t is UTF-32 because units only contain characters
   // that have the same representation in UTF-16 and UTF-32.
   utf8_to_utf16 u(unit);
@@ -1685,7 +1721,7 @@ OutputIt copy_unit(string_view unit, OutputIt out, wchar_t) {
 }
 
 template <typename Char, typename Period, typename OutputIt>
-OutputIt format_duration_unit(OutputIt out) {
+auto format_duration_unit(OutputIt out) -> OutputIt {
   if (const char* unit = get_units<Period>())
     return copy_unit(string_view(unit), out, Char());
   *out++ = '[';
@@ -1752,18 +1788,12 @@ struct chrono_formatter {
 
     // this may overflow and/or the result may not fit in the
     // target type.
-#if FMT_SAFE_DURATION_CAST
     // might need checked conversion (rep!=Rep)
-    auto tmpval = std::chrono::duration<rep, Period>(val);
-    s = fmt_safe_duration_cast<seconds>(tmpval);
-#else
-    s = std::chrono::duration_cast<seconds>(
-        std::chrono::duration<rep, Period>(val));
-#endif
+    s = fmt_duration_cast<seconds>(std::chrono::duration<rep, Period>(val));
   }
 
   // returns true if nan or inf, writes to out.
-  bool handle_nan_inf() {
+  auto handle_nan_inf() -> bool {
     if (isfinite(val)) {
       return false;
     }
@@ -1780,17 +1810,22 @@ struct chrono_formatter {
     return true;
   }
 
-  Rep hour() const { return static_cast<Rep>(mod((s.count() / 3600), 24)); }
+  auto days() const -> Rep { return static_cast<Rep>(s.count() / 86400); }
+  auto hour() const -> Rep {
+    return static_cast<Rep>(mod((s.count() / 3600), 24));
+  }
 
-  Rep hour12() const {
+  auto hour12() const -> Rep {
     Rep hour = static_cast<Rep>(mod((s.count() / 3600), 12));
     return hour <= 0 ? 12 : hour;
   }
 
-  Rep minute() const { return static_cast<Rep>(mod((s.count() / 60), 60)); }
-  Rep second() const { return static_cast<Rep>(mod(s.count(), 60)); }
+  auto minute() const -> Rep {
+    return static_cast<Rep>(mod((s.count() / 60), 60));
+  }
+  auto second() const -> Rep { return static_cast<Rep>(mod(s.count(), 60)); }
 
-  std::tm time() const {
+  auto time() const -> std::tm {
     auto time = std::tm();
     time.tm_hour = to_nonnegative_int(hour(), 24);
     time.tm_min = to_nonnegative_int(minute(), 60);
@@ -1858,10 +1893,14 @@ struct chrono_formatter {
   void on_dec0_week_of_year(numeric_system) {}
   void on_dec1_week_of_year(numeric_system) {}
   void on_iso_week_of_year(numeric_system) {}
-  void on_day_of_year() {}
   void on_day_of_month(numeric_system) {}
   void on_day_of_month_space(numeric_system) {}
 
+  void on_day_of_year() {
+    if (handle_nan_inf()) return;
+    write(days(), 0);
+  }
+
   void on_24_hour(numeric_system ns, pad_type pad) {
     if (handle_nan_inf()) return;
 
@@ -1968,7 +2007,7 @@ class weekday {
   weekday() = default;
   explicit constexpr weekday(unsigned wd) noexcept
       : value(static_cast<unsigned char>(wd != 7 ? wd : 0)) {}
-  constexpr unsigned c_encoding() const noexcept { return value; }
+  constexpr auto c_encoding() const noexcept -> unsigned { return value; }
 };
 
 class year_month_day {};
@@ -2083,25 +2122,22 @@ struct formatter<std::chrono::time_point<std::chrono::system_clock, Duration>,
             period::num != 1 || period::den != 1 ||
             std::is_floating_point<typename Duration::rep>::value)) {
       const auto epoch = val.time_since_epoch();
-      auto subsecs = std::chrono::duration_cast<Duration>(
-          epoch - std::chrono::duration_cast<std::chrono::seconds>(epoch));
+      auto subsecs = detail::fmt_duration_cast<Duration>(
+          epoch - detail::fmt_duration_cast<std::chrono::seconds>(epoch));
 
       if (subsecs.count() < 0) {
         auto second =
-            std::chrono::duration_cast<Duration>(std::chrono::seconds(1));
+            detail::fmt_duration_cast<Duration>(std::chrono::seconds(1));
         if (epoch.count() < ((Duration::min)() + second).count())
           FMT_THROW(format_error("duration is too small"));
         subsecs += second;
         val -= second;
       }
 
-      return formatter<std::tm, Char>::do_format(
-          gmtime(std::chrono::time_point_cast<std::chrono::seconds>(val)), ctx,
-          &subsecs);
+      return formatter<std::tm, Char>::do_format(gmtime(val), ctx, &subsecs);
     }
 
-    return formatter<std::tm, Char>::format(
-        gmtime(std::chrono::time_point_cast<std::chrono::seconds>(val)), ctx);
+    return formatter<std::tm, Char>::format(gmtime(val), ctx);
   }
 };
 
@@ -2120,17 +2156,13 @@ struct formatter<std::chrono::local_time<Duration>, Char>
     if (period::num != 1 || period::den != 1 ||
         std::is_floating_point<typename Duration::rep>::value) {
       const auto epoch = val.time_since_epoch();
-      const auto subsecs = std::chrono::duration_cast<Duration>(
-          epoch - std::chrono::duration_cast<std::chrono::seconds>(epoch));
+      const auto subsecs = detail::fmt_duration_cast<Duration>(
+          epoch - detail::fmt_duration_cast<std::chrono::seconds>(epoch));
 
-      return formatter<std::tm, Char>::do_format(
-          localtime(std::chrono::time_point_cast<std::chrono::seconds>(val)),
-          ctx, &subsecs);
+      return formatter<std::tm, Char>::do_format(localtime(val), ctx, &subsecs);
     }
 
-    return formatter<std::tm, Char>::format(
-        localtime(std::chrono::time_point_cast<std::chrono::seconds>(val)),
-        ctx);
+    return formatter<std::tm, Char>::format(localtime(val), ctx);
   }
 };
 #endif

wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/color.h

@@ -233,7 +233,7 @@ class text_style {
   FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept
       : set_foreground_color(), set_background_color(), ems(em) {}
 
-  FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) {
+  FMT_CONSTEXPR auto operator|=(const text_style& rhs) -> text_style& {
     if (!set_foreground_color) {
       set_foreground_color = rhs.set_foreground_color;
       foreground_color = rhs.foreground_color;
@@ -257,29 +257,29 @@ class text_style {
     return *this;
   }
 
-  friend FMT_CONSTEXPR text_style operator|(text_style lhs,
-                                            const text_style& rhs) {
+  friend FMT_CONSTEXPR auto operator|(text_style lhs, const text_style& rhs)
+      -> text_style {
     return lhs |= rhs;
   }
 
-  FMT_CONSTEXPR bool has_foreground() const noexcept {
+  FMT_CONSTEXPR auto has_foreground() const noexcept -> bool {
     return set_foreground_color;
   }
-  FMT_CONSTEXPR bool has_background() const noexcept {
+  FMT_CONSTEXPR auto has_background() const noexcept -> bool {
     return set_background_color;
   }
-  FMT_CONSTEXPR bool has_emphasis() const noexcept {
+  FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool {
     return static_cast<uint8_t>(ems) != 0;
   }
-  FMT_CONSTEXPR detail::color_type get_foreground() const noexcept {
+  FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type {
     FMT_ASSERT(has_foreground(), "no foreground specified for this style");
     return foreground_color;
   }
-  FMT_CONSTEXPR detail::color_type get_background() const noexcept {
+  FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type {
     FMT_ASSERT(has_background(), "no background specified for this style");
     return background_color;
   }
-  FMT_CONSTEXPR emphasis get_emphasis() const noexcept {
+  FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis {
     FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
     return ems;
   }
@@ -297,9 +297,11 @@ class text_style {
     }
   }
 
-  friend FMT_CONSTEXPR text_style fg(detail::color_type foreground) noexcept;
+  friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept
+      -> text_style;
 
-  friend FMT_CONSTEXPR text_style bg(detail::color_type background) noexcept;
+  friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept
+      -> text_style;
 
   detail::color_type foreground_color;
   detail::color_type background_color;
@@ -309,16 +311,19 @@ class text_style {
 };
 
 /** Creates a text style from the foreground (text) color. */
-FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) noexcept {
+FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept
+    -> text_style {
   return text_style(true, foreground);
 }
 
 /** Creates a text style from the background color. */
-FMT_CONSTEXPR inline text_style bg(detail::color_type background) noexcept {
+FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept
+    -> text_style {
   return text_style(false, background);
 }
 
-FMT_CONSTEXPR inline text_style operator|(emphasis lhs, emphasis rhs) noexcept {
+FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept
+    -> text_style {
   return text_style(lhs) | rhs;
 }
 
@@ -384,8 +389,8 @@ template <typename Char> struct ansi_color_escape {
   }
   FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; }
 
-  FMT_CONSTEXPR const Char* begin() const noexcept { return buffer; }
-  FMT_CONSTEXPR_CHAR_TRAITS const Char* end() const noexcept {
+  FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; }
+  FMT_CONSTEXPR_CHAR_TRAITS auto end() const noexcept -> const Char* {
     return buffer + std::char_traits<Char>::length(buffer);
   }
 
@@ -400,25 +405,27 @@ template <typename Char> struct ansi_color_escape {
     out[2] = static_cast<Char>('0' + c % 10);
     out[3] = static_cast<Char>(delimiter);
   }
-  static FMT_CONSTEXPR bool has_emphasis(emphasis em, emphasis mask) noexcept {
+  static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept
+      -> bool {
     return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask);
   }
 };
 
 template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
-    detail::color_type foreground) noexcept {
+FMT_CONSTEXPR auto make_foreground_color(detail::color_type foreground) noexcept
+    -> ansi_color_escape<Char> {
   return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
 }
 
 template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(
-    detail::color_type background) noexcept {
+FMT_CONSTEXPR auto make_background_color(detail::color_type background) noexcept
+    -> ansi_color_escape<Char> {
   return ansi_color_escape<Char>(background, "\x1b[48;2;");
 }
 
 template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) noexcept {
+FMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept
+    -> ansi_color_escape<Char> {
   return ansi_color_escape<Char>(em);
 }
 
@@ -427,9 +434,10 @@ template <typename Char> inline void reset_color(buffer<Char>& buffer) {
   buffer.append(reset_color.begin(), reset_color.end());
 }
 
-template <typename T> struct styled_arg {
+template <typename T> struct styled_arg : detail::view {
   const T& value;
   text_style style;
+  styled_arg(const T& v, text_style s) : value(v), style(s) {}
 };
 
 template <typename Char>
@@ -510,9 +518,10 @@ void print(const text_style& ts, const S& format_str, const Args&... args) {
 }
 
 template <typename S, typename Char = char_t<S>>
-inline std::basic_string<Char> vformat(
+inline auto vformat(
     const text_style& ts, const S& format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
   basic_memory_buffer<Char> buf;
   detail::vformat_to(buf, ts, detail::to_string_view(format_str), args);
   return fmt::to_string(buf);
@@ -531,8 +540,8 @@ inline std::basic_string<Char> vformat(
   \endrst
 */
 template <typename S, typename... Args, typename Char = char_t<S>>
-inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
-                                      const Args&... args) {
+inline auto format(const text_style& ts, const S& format_str,
+                   const Args&... args) -> std::basic_string<Char> {
   return fmt::vformat(ts, detail::to_string_view(format_str),
                       fmt::make_format_args<buffer_context<Char>>(args...));
 }
@@ -542,9 +551,10 @@ inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
  */
 template <typename OutputIt, typename Char,
           FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)>
-OutputIt vformat_to(
-    OutputIt out, const text_style& ts, basic_string_view<Char> format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+auto vformat_to(OutputIt out, const text_style& ts,
+                basic_string_view<Char> format_str,
+                basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> OutputIt {
   auto&& buf = detail::get_buffer<Char>(out);
   detail::vformat_to(buf, ts, format_str, args);
   return detail::get_iterator(buf, out);
@@ -562,9 +572,10 @@ OutputIt vformat_to(
                    fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
   \endrst
 */
-template <typename OutputIt, typename S, typename... Args,
-          bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value&&
-              detail::is_string<S>::value>
+template <
+    typename OutputIt, typename S, typename... Args,
+    bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value &&
+                  detail::is_string<S>::value>
 inline auto format_to(OutputIt out, const text_style& ts, const S& format_str,
                       Args&&... args) ->
     typename std::enable_if<enable, OutputIt>::type {

wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/compile.h

@@ -14,8 +14,8 @@ FMT_BEGIN_NAMESPACE
 namespace detail {
 
 template <typename Char, typename InputIt>
-FMT_CONSTEXPR inline counting_iterator copy_str(InputIt begin, InputIt end,
-                                                counting_iterator it) {
+FMT_CONSTEXPR inline auto copy_str(InputIt begin, InputIt end,
+                                   counting_iterator it) -> counting_iterator {
   return it + (end - begin);
 }
 
@@ -57,7 +57,7 @@ struct udl_compiled_string : compiled_string {
 #endif
 
 template <typename T, typename... Tail>
-const T& first(const T& value, const Tail&...) {
+auto first(const T& value, const Tail&...) -> const T& {
   return value;
 }
 
@@ -488,18 +488,19 @@ FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
 
 template <typename OutputIt, typename S, typename... Args,
           FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n,
-                                         const S& format_str, Args&&... args) {
+auto format_to_n(OutputIt out, size_t n, const S& format_str, Args&&... args)
+    -> format_to_n_result<OutputIt> {
   using traits = detail::fixed_buffer_traits;
   auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
-  format_to(std::back_inserter(buf), format_str, std::forward<Args>(args)...);
+  fmt::format_to(std::back_inserter(buf), format_str,
+                 std::forward<Args>(args)...);
   return {buf.out(), buf.count()};
 }
 
 template <typename S, typename... Args,
           FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-FMT_CONSTEXPR20 size_t formatted_size(const S& format_str,
-                                      const Args&... args) {
+FMT_CONSTEXPR20 auto formatted_size(const S& format_str, const Args&... args)
+    -> size_t {
   return fmt::format_to(detail::counting_iterator(), format_str, args...)
       .count();
 }

wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/core.h

@@ -18,7 +18,7 @@
 #include <type_traits>
 
 // The fmt library version in the form major * 10000 + minor * 100 + patch.
-#define FMT_VERSION 100100
+#define FMT_VERSION 100201
 
 #if defined(__clang__) && !defined(__ibmxl__)
 #  define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
@@ -105,9 +105,12 @@
 #  define FMT_CONSTEXPR
 #endif
 
-#if ((FMT_CPLUSPLUS >= 202002L) &&                            \
-     (!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE > 9)) || \
-    (FMT_CPLUSPLUS >= 201709L && FMT_GCC_VERSION >= 1002)
+#if (FMT_CPLUSPLUS >= 202002L ||                                \
+     (FMT_CPLUSPLUS >= 201709L && FMT_GCC_VERSION >= 1002)) &&  \
+    ((!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE >= 10) &&  \
+     (!defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 10000) && \
+     (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1928)) &&          \
+    defined(__cpp_lib_is_constant_evaluated)
 #  define FMT_CONSTEXPR20 constexpr
 #else
 #  define FMT_CONSTEXPR20
@@ -185,18 +188,20 @@
 #  define FMT_END_EXPORT
 #endif
 
+#if FMT_GCC_VERSION || FMT_CLANG_VERSION
+#  define FMT_VISIBILITY(value) __attribute__((visibility(value)))
+#else
+#  define FMT_VISIBILITY(value)
+#endif
+
 #if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
-#  ifdef FMT_LIB_EXPORT
+#  if defined(FMT_LIB_EXPORT)
 #    define FMT_API __declspec(dllexport)
 #  elif defined(FMT_SHARED)
 #    define FMT_API __declspec(dllimport)
 #  endif
-#else
-#  if defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)
-#    if defined(__GNUC__) || defined(__clang__)
-#      define FMT_API __attribute__((visibility("default")))
-#    endif
-#  endif
+#elif defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)
+#  define FMT_API FMT_VISIBILITY("default")
 #endif
 #ifndef FMT_API
 #  define FMT_API
@@ -222,8 +227,9 @@
         __apple_build_version__ >= 14000029L) &&                 \
        FMT_CPLUSPLUS >= 202002L) ||                              \
       (defined(__cpp_consteval) &&                               \
-       (!FMT_MSC_VERSION || _MSC_FULL_VER >= 193030704))
-// consteval is broken in MSVC before VS2022 and Apple clang before 14.
+       (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1929))
+// consteval is broken in MSVC before VS2019 version 16.10 and Apple clang
+// before 14.
 #    define FMT_CONSTEVAL consteval
 #    define FMT_HAS_CONSTEVAL
 #  else
@@ -242,6 +248,15 @@
 #  endif
 #endif
 
+// GCC < 5 requires this-> in decltype
+#ifndef FMT_DECLTYPE_THIS
+#  if FMT_GCC_VERSION && FMT_GCC_VERSION < 500
+#    define FMT_DECLTYPE_THIS this->
+#  else
+#    define FMT_DECLTYPE_THIS
+#  endif
+#endif
+
 // Enable minimal optimizations for more compact code in debug mode.
 FMT_GCC_PRAGMA("GCC push_options")
 #if !defined(__OPTIMIZE__) && !defined(__NVCOMPILER) && !defined(__LCC__) && \
@@ -263,7 +278,9 @@ template <typename T>
 using remove_const_t = typename std::remove_const<T>::type;
 template <typename T>
 using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
-template <typename T> struct type_identity { using type = T; };
+template <typename T> struct type_identity {
+  using type = T;
+};
 template <typename T> using type_identity_t = typename type_identity<T>::type;
 template <typename T>
 using underlying_t = typename std::underlying_type<T>::type;
@@ -454,15 +471,15 @@ template <typename Char> class basic_string_view {
     size_ -= n;
   }
 
-  FMT_CONSTEXPR_CHAR_TRAITS bool starts_with(
-      basic_string_view<Char> sv) const noexcept {
+  FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(
+      basic_string_view<Char> sv) const noexcept -> bool {
     return size_ >= sv.size_ &&
            std::char_traits<Char>::compare(data_, sv.data_, sv.size_) == 0;
   }
-  FMT_CONSTEXPR_CHAR_TRAITS bool starts_with(Char c) const noexcept {
+  FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(Char c) const noexcept -> bool {
     return size_ >= 1 && std::char_traits<Char>::eq(*data_, c);
   }
-  FMT_CONSTEXPR_CHAR_TRAITS bool starts_with(const Char* s) const {
+  FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(const Char* s) const -> bool {
     return starts_with(basic_string_view<Char>(s));
   }
 
@@ -600,10 +617,10 @@ FMT_TYPE_CONSTANT(const Char*, cstring_type);
 FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);
 FMT_TYPE_CONSTANT(const void*, pointer_type);
 
-constexpr bool is_integral_type(type t) {
+constexpr auto is_integral_type(type t) -> bool {
   return t > type::none_type && t <= type::last_integer_type;
 }
-constexpr bool is_arithmetic_type(type t) {
+constexpr auto is_arithmetic_type(type t) -> bool {
   return t > type::none_type && t <= type::last_numeric_type;
 }
 
@@ -627,6 +644,7 @@ enum {
   pointer_set = set(type::pointer_type)
 };
 
+// DEPRECATED!
 FMT_NORETURN FMT_API void throw_format_error(const char* message);
 
 struct error_handler {
@@ -804,7 +822,7 @@ template <typename T> class buffer {
  protected:
   // Don't initialize ptr_ since it is not accessed to save a few cycles.
   FMT_MSC_WARNING(suppress : 26495)
-  buffer(size_t sz) noexcept : size_(sz), capacity_(sz) {}
+  FMT_CONSTEXPR buffer(size_t sz) noexcept : size_(sz), capacity_(sz) {}
 
   FMT_CONSTEXPR20 buffer(T* p = nullptr, size_t sz = 0, size_t cap = 0) noexcept
       : ptr_(p), size_(sz), capacity_(cap) {}
@@ -819,6 +837,7 @@ template <typename T> class buffer {
   }
 
   /** Increases the buffer capacity to hold at least *capacity* elements. */
+  // DEPRECATED!
   virtual FMT_CONSTEXPR20 void grow(size_t capacity) = 0;
 
  public:
@@ -1305,6 +1324,7 @@ template <typename Context> class value {
     parse_ctx.advance_to(f.parse(parse_ctx));
     using qualified_type =
         conditional_t<has_const_formatter<T, Context>(), const T, T>;
+    // Calling format through a mutable reference is deprecated.
     ctx.advance_to(f.format(*static_cast<qualified_type*>(arg), ctx));
   }
 };
@@ -1318,7 +1338,7 @@ using ulong_type = conditional_t<long_short, unsigned, unsigned long long>;
 template <typename T> struct format_as_result {
   template <typename U,
             FMT_ENABLE_IF(std::is_enum<U>::value || std::is_class<U>::value)>
-  static auto map(U*) -> decltype(format_as(std::declval<U>()));
+  static auto map(U*) -> remove_cvref_t<decltype(format_as(std::declval<U>()))>;
   static auto map(...) -> void;
 
   using type = decltype(map(static_cast<T*>(nullptr)));
@@ -1435,7 +1455,8 @@ template <typename Context> struct arg_mapper {
   // Only map owning types because mapping views can be unsafe.
   template <typename T, typename U = format_as_t<T>,
             FMT_ENABLE_IF(std::is_arithmetic<U>::value)>
-  FMT_CONSTEXPR FMT_INLINE auto map(const T& val) -> decltype(map(U())) {
+  FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
+      -> decltype(FMT_DECLTYPE_THIS map(U())) {
     return map(format_as(val));
   }
 
@@ -1459,13 +1480,14 @@ template <typename Context> struct arg_mapper {
                           !is_string<U>::value && !is_char<U>::value &&
                           !is_named_arg<U>::value &&
                           !std::is_arithmetic<format_as_t<U>>::value)>
-  FMT_CONSTEXPR FMT_INLINE auto map(T& val) -> decltype(do_map(val)) {
+  FMT_CONSTEXPR FMT_INLINE auto map(T& val)
+      -> decltype(FMT_DECLTYPE_THIS do_map(val)) {
     return do_map(val);
   }
 
   template <typename T, FMT_ENABLE_IF(is_named_arg<T>::value)>
   FMT_CONSTEXPR FMT_INLINE auto map(const T& named_arg)
-      -> decltype(map(named_arg.value)) {
+      -> decltype(FMT_DECLTYPE_THIS map(named_arg.value)) {
     return map(named_arg.value);
   }
 
@@ -1504,7 +1526,9 @@ FMT_CONSTEXPR auto copy_str(R&& rng, OutputIt out) -> OutputIt {
 
 #if FMT_GCC_VERSION && FMT_GCC_VERSION < 500
 // A workaround for gcc 4.8 to make void_t work in a SFINAE context.
-template <typename...> struct void_t_impl { using type = void; };
+template <typename...> struct void_t_impl {
+  using type = void;
+};
 template <typename... T> using void_t = typename void_t_impl<T...>::type;
 #else
 template <typename...> using void_t = void;
@@ -1598,8 +1622,8 @@ FMT_CONSTEXPR inline auto make_arg(T& val) -> basic_format_arg<Context> {
 }  // namespace detail
 FMT_BEGIN_EXPORT
 
-// A formatting argument. It is a trivially copyable/constructible type to
-// allow storage in basic_memory_buffer.
+// A formatting argument. Context is a template parameter for the compiled API
+// where output can be unbuffered.
 template <typename Context> class basic_format_arg {
  private:
   detail::value<Context> value_;
@@ -1651,6 +1675,15 @@ template <typename Context> class basic_format_arg {
   auto is_arithmetic() const -> bool {
     return detail::is_arithmetic_type(type_);
   }
+
+  FMT_INLINE auto format_custom(const char_type* parse_begin,
+                                typename Context::parse_context_type& parse_ctx,
+                                Context& ctx) -> bool {
+    if (type_ != detail::type::custom_type) return false;
+    parse_ctx.advance_to(parse_begin);
+    value_.custom.format(value_.custom.value, parse_ctx, ctx);
+    return true;
+  }
 };
 
 /**
@@ -1739,6 +1772,7 @@ template <typename OutputIt, typename Char> class basic_format_context {
   }
   auto args() const -> const format_args& { return args_; }
 
+  // DEPRECATED!
   FMT_CONSTEXPR auto error_handler() -> detail::error_handler { return {}; }
   void on_error(const char* message) { error_handler().on_error(message); }
 
@@ -2300,9 +2334,12 @@ FMT_CONSTEXPR FMT_INLINE auto parse_format_specs(
     dynamic_format_specs<Char>& specs;
     type arg_type;
 
-    FMT_CONSTEXPR auto operator()(pres type, int set) -> const Char* {
-      if (!in(arg_type, set)) throw_format_error("invalid format specifier");
-      specs.type = type;
+    FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* {
+      if (!in(arg_type, set)) {
+        if (arg_type == type::none_type) return begin;
+        throw_format_error("invalid format specifier");
+      }
+      specs.type = pres_type;
       return begin + 1;
     }
   } parse_presentation_type{begin, specs, arg_type};
@@ -2319,6 +2356,7 @@ FMT_CONSTEXPR FMT_INLINE auto parse_format_specs(
     case '+':
     case '-':
     case ' ':
+      if (arg_type == type::none_type) return begin;
       enter_state(state::sign, in(arg_type, sint_set | float_set));
       switch (c) {
       case '+':
@@ -2334,14 +2372,17 @@ FMT_CONSTEXPR FMT_INLINE auto parse_format_specs(
       ++begin;
       break;
     case '#':
+      if (arg_type == type::none_type) return begin;
       enter_state(state::hash, is_arithmetic_type(arg_type));
       specs.alt = true;
       ++begin;
       break;
     case '0':
       enter_state(state::zero);
-      if (!is_arithmetic_type(arg_type))
+      if (!is_arithmetic_type(arg_type)) {
+        if (arg_type == type::none_type) return begin;
         throw_format_error("format specifier requires numeric argument");
+      }
       if (specs.align == align::none) {
         // Ignore 0 if align is specified for compatibility with std::format.
         specs.align = align::numeric;
@@ -2363,12 +2404,14 @@ FMT_CONSTEXPR FMT_INLINE auto parse_format_specs(
       begin = parse_dynamic_spec(begin, end, specs.width, specs.width_ref, ctx);
       break;
     case '.':
+      if (arg_type == type::none_type) return begin;
       enter_state(state::precision,
                   in(arg_type, float_set | string_set | cstring_set));
       begin = parse_precision(begin, end, specs.precision, specs.precision_ref,
                               ctx);
       break;
     case 'L':
+      if (arg_type == type::none_type) return begin;
       enter_state(state::locale, is_arithmetic_type(arg_type));
       specs.localized = true;
       ++begin;
@@ -2402,6 +2445,8 @@ FMT_CONSTEXPR FMT_INLINE auto parse_format_specs(
     case 'G':
       return parse_presentation_type(pres::general_upper, float_set);
     case 'c':
+      if (arg_type == type::bool_type)
+        throw_format_error("invalid format specifier");
       return parse_presentation_type(pres::chr, integral_set);
     case 's':
       return parse_presentation_type(pres::string,
@@ -2541,8 +2586,8 @@ FMT_CONSTEXPR auto parse_format_specs(ParseContext& ctx)
       decltype(arg_mapper<context>().map(std::declval<const T&>())),
       typename strip_named_arg<T>::type>;
 #if defined(__cpp_if_constexpr)
-  if constexpr (std::is_default_constructible_v<
-                    formatter<mapped_type, char_type>>) {
+  if constexpr (std::is_default_constructible<
+                    formatter<mapped_type, char_type>>::value) {
     return formatter<mapped_type, char_type>().parse(ctx);
   } else {
     type_is_unformattable_for<T, char_type> _;
@@ -2667,7 +2712,9 @@ template <typename Char = char> struct vformat_args {
   using type = basic_format_args<
       basic_format_context<std::back_insert_iterator<buffer<Char>>, Char>>;
 };
-template <> struct vformat_args<char> { using type = format_args; };
+template <> struct vformat_args<char> {
+  using type = format_args;
+};
 
 // Use vformat_args and avoid type_identity to keep symbols short.
 template <typename Char>

wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/format-inl.h

@@ -18,7 +18,7 @@
 #  include <locale>
 #endif
 
-#ifdef _WIN32
+#if defined(_WIN32) && !defined(FMT_WINDOWS_NO_WCHAR)
 #  include <io.h>  // _isatty
 #endif
 
@@ -58,8 +58,8 @@ FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
   error_code_size += detail::to_unsigned(detail::count_digits(abs_value));
   auto it = buffer_appender<char>(out);
   if (message.size() <= inline_buffer_size - error_code_size)
-    format_to(it, FMT_STRING("{}{}"), message, SEP);
-  format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
+    fmt::format_to(it, FMT_STRING("{}{}"), message, SEP);
+  fmt::format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
   FMT_ASSERT(out.size() <= inline_buffer_size, "");
 }
 
@@ -73,9 +73,10 @@ FMT_FUNC void report_error(format_func func, int error_code,
 }
 
 // A wrapper around fwrite that throws on error.
-inline void fwrite_fully(const void* ptr, size_t size, size_t count,
-                         FILE* stream) {
-  std::fwrite(ptr, size, count, stream);
+inline void fwrite_fully(const void* ptr, size_t count, FILE* stream) {
+  size_t written = std::fwrite(ptr, 1, count, stream);
+  if (written < count)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }
 
 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
@@ -84,7 +85,7 @@ locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
   static_assert(std::is_same<Locale, std::locale>::value, "");
 }
 
-template <typename Locale> Locale locale_ref::get() const {
+template <typename Locale> auto locale_ref::get() const -> Locale {
   static_assert(std::is_same<Locale, std::locale>::value, "");
   return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
 }
@@ -96,7 +97,8 @@ FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> {
   auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
   return {std::move(grouping), thousands_sep};
 }
-template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) {
+template <typename Char>
+FMT_FUNC auto decimal_point_impl(locale_ref loc) -> Char {
   return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
       .decimal_point();
 }
@@ -142,24 +144,25 @@ FMT_API FMT_FUNC auto format_facet<std::locale>::do_put(
 }
 #endif
 
-FMT_FUNC std::system_error vsystem_error(int error_code, string_view fmt,
-                                         format_args args) {
+FMT_FUNC auto vsystem_error(int error_code, string_view fmt, format_args args)
+    -> std::system_error {
   auto ec = std::error_code(error_code, std::generic_category());
   return std::system_error(ec, vformat(fmt, args));
 }
 
 namespace detail {
 
-template <typename F> inline bool operator==(basic_fp<F> x, basic_fp<F> y) {
+template <typename F>
+inline auto operator==(basic_fp<F> x, basic_fp<F> y) -> bool {
   return x.f == y.f && x.e == y.e;
 }
 
 // Compilers should be able to optimize this into the ror instruction.
-FMT_CONSTEXPR inline uint32_t rotr(uint32_t n, uint32_t r) noexcept {
+FMT_CONSTEXPR inline auto rotr(uint32_t n, uint32_t r) noexcept -> uint32_t {
   r &= 31;
   return (n >> r) | (n << (32 - r));
 }
-FMT_CONSTEXPR inline uint64_t rotr(uint64_t n, uint32_t r) noexcept {
+FMT_CONSTEXPR inline auto rotr(uint64_t n, uint32_t r) noexcept -> uint64_t {
   r &= 63;
   return (n >> r) | (n << (64 - r));
 }
@@ -168,14 +171,14 @@ FMT_CONSTEXPR inline uint64_t rotr(uint64_t n, uint32_t r) noexcept {
 namespace dragonbox {
 // Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a
 // 64-bit unsigned integer.
-inline uint64_t umul96_upper64(uint32_t x, uint64_t y) noexcept {
+inline auto umul96_upper64(uint32_t x, uint64_t y) noexcept -> uint64_t {
   return umul128_upper64(static_cast<uint64_t>(x) << 32, y);
 }
 
 // Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a
 // 128-bit unsigned integer.
-inline uint128_fallback umul192_lower128(uint64_t x,
-                                         uint128_fallback y) noexcept {
+inline auto umul192_lower128(uint64_t x, uint128_fallback y) noexcept
+    -> uint128_fallback {
   uint64_t high = x * y.high();
   uint128_fallback high_low = umul128(x, y.low());
   return {high + high_low.high(), high_low.low()};
@@ -183,12 +186,12 @@ inline uint128_fallback umul192_lower128(uint64_t x,
 
 // Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a
 // 64-bit unsigned integer.
-inline uint64_t umul96_lower64(uint32_t x, uint64_t y) noexcept {
+inline auto umul96_lower64(uint32_t x, uint64_t y) noexcept -> uint64_t {
   return x * y;
 }
 
 // Various fast log computations.
-inline int floor_log10_pow2_minus_log10_4_over_3(int e) noexcept {
+inline auto floor_log10_pow2_minus_log10_4_over_3(int e) noexcept -> int {
   FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent");
   return (e * 631305 - 261663) >> 21;
 }
@@ -202,7 +205,7 @@ FMT_INLINE_VARIABLE constexpr struct {
 // divisible by pow(10, N).
 // Precondition: n <= pow(10, N + 1).
 template <int N>
-bool check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept {
+auto check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept -> bool {
   // The numbers below are chosen such that:
   //   1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100,
   //   2. nm mod 2^k < m if and only if n is divisible by d,
@@ -227,7 +230,7 @@ bool check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept {
 
 // Computes floor(n / pow(10, N)) for small n and N.
 // Precondition: n <= pow(10, N + 1).
-template <int N> uint32_t small_division_by_pow10(uint32_t n) noexcept {
+template <int N> auto small_division_by_pow10(uint32_t n) noexcept -> uint32_t {
   constexpr auto info = div_small_pow10_infos[N - 1];
   FMT_ASSERT(n <= info.divisor * 10, "n is too large");
   constexpr uint32_t magic_number =
@@ -236,12 +239,12 @@ template <int N> uint32_t small_division_by_pow10(uint32_t n) noexcept {
 }
 
 // Computes floor(n / 10^(kappa + 1)) (float)
-inline uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) noexcept {
+inline auto divide_by_10_to_kappa_plus_1(uint32_t n) noexcept -> uint32_t {
   // 1374389535 = ceil(2^37/100)
   return static_cast<uint32_t>((static_cast<uint64_t>(n) * 1374389535) >> 37);
 }
 // Computes floor(n / 10^(kappa + 1)) (double)
-inline uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) noexcept {
+inline auto divide_by_10_to_kappa_plus_1(uint64_t n) noexcept -> uint64_t {
   // 2361183241434822607 = ceil(2^(64+7)/1000)
   return umul128_upper64(n, 2361183241434822607ull) >> 7;
 }
@@ -253,7 +256,7 @@ template <> struct cache_accessor<float> {
   using carrier_uint = float_info<float>::carrier_uint;
   using cache_entry_type = uint64_t;
 
-  static uint64_t get_cached_power(int k) noexcept {
+  static auto get_cached_power(int k) noexcept -> uint64_t {
     FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k,
                "k is out of range");
     static constexpr const uint64_t pow10_significands[] = {
@@ -295,20 +298,23 @@ template <> struct cache_accessor<float> {
     bool is_integer;
   };
 
-  static compute_mul_result compute_mul(
-      carrier_uint u, const cache_entry_type& cache) noexcept {
+  static auto compute_mul(carrier_uint u,
+                          const cache_entry_type& cache) noexcept
+      -> compute_mul_result {
     auto r = umul96_upper64(u, cache);
     return {static_cast<carrier_uint>(r >> 32),
             static_cast<carrier_uint>(r) == 0};
   }
 
-  static uint32_t compute_delta(const cache_entry_type& cache,
-                                int beta) noexcept {
+  static auto compute_delta(const cache_entry_type& cache, int beta) noexcept
+      -> uint32_t {
     return static_cast<uint32_t>(cache >> (64 - 1 - beta));
   }
 
-  static compute_mul_parity_result compute_mul_parity(
-      carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept {
+  static auto compute_mul_parity(carrier_uint two_f,
+                                 const cache_entry_type& cache,
+                                 int beta) noexcept
+      -> compute_mul_parity_result {
     FMT_ASSERT(beta >= 1, "");
     FMT_ASSERT(beta < 64, "");
 
@@ -317,22 +323,22 @@ template <> struct cache_accessor<float> {
             static_cast<uint32_t>(r >> (32 - beta)) == 0};
   }
 
-  static carrier_uint compute_left_endpoint_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta) noexcept {
+  static auto compute_left_endpoint_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
     return static_cast<carrier_uint>(
         (cache - (cache >> (num_significand_bits<float>() + 2))) >>
         (64 - num_significand_bits<float>() - 1 - beta));
   }
 
-  static carrier_uint compute_right_endpoint_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta) noexcept {
+  static auto compute_right_endpoint_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
     return static_cast<carrier_uint>(
         (cache + (cache >> (num_significand_bits<float>() + 1))) >>
         (64 - num_significand_bits<float>() - 1 - beta));
   }
 
-  static carrier_uint compute_round_up_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta) noexcept {
+  static auto compute_round_up_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
     return (static_cast<carrier_uint>(
                 cache >> (64 - num_significand_bits<float>() - 2 - beta)) +
             1) /
@@ -344,7 +350,7 @@ template <> struct cache_accessor<double> {
   using carrier_uint = float_info<double>::carrier_uint;
   using cache_entry_type = uint128_fallback;
 
-  static uint128_fallback get_cached_power(int k) noexcept {
+  static auto get_cached_power(int k) noexcept -> uint128_fallback {
     FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k,
                "k is out of range");
 
@@ -983,8 +989,7 @@ template <> struct cache_accessor<double> {
       {0xe0accfa875af45a7, 0x93eb1b80a33b8606},
       {0x8c6c01c9498d8b88, 0xbc72f130660533c4},
       {0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5},
-      { 0xdb68c2ca82ed2a05,
-        0xa67398db9f6820e2 }
+      {0xdb68c2ca82ed2a05, 0xa67398db9f6820e2},
 #else
       {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
       {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
@@ -1069,19 +1074,22 @@ template <> struct cache_accessor<double> {
     bool is_integer;
   };
 
-  static compute_mul_result compute_mul(
-      carrier_uint u, const cache_entry_type& cache) noexcept {
+  static auto compute_mul(carrier_uint u,
+                          const cache_entry_type& cache) noexcept
+      -> compute_mul_result {
     auto r = umul192_upper128(u, cache);
     return {r.high(), r.low() == 0};
   }
 
-  static uint32_t compute_delta(cache_entry_type const& cache,
-                                int beta) noexcept {
+  static auto compute_delta(cache_entry_type const& cache, int beta) noexcept
+      -> uint32_t {
     return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta));
   }
 
-  static compute_mul_parity_result compute_mul_parity(
-      carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept {
+  static auto compute_mul_parity(carrier_uint two_f,
+                                 const cache_entry_type& cache,
+                                 int beta) noexcept
+      -> compute_mul_parity_result {
     FMT_ASSERT(beta >= 1, "");
     FMT_ASSERT(beta < 64, "");
 
@@ -1090,35 +1098,35 @@ template <> struct cache_accessor<double> {
             ((r.high() << beta) | (r.low() >> (64 - beta))) == 0};
   }
 
-  static carrier_uint compute_left_endpoint_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta) noexcept {
+  static auto compute_left_endpoint_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
     return (cache.high() -
             (cache.high() >> (num_significand_bits<double>() + 2))) >>
            (64 - num_significand_bits<double>() - 1 - beta);
   }
 
-  static carrier_uint compute_right_endpoint_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta) noexcept {
+  static auto compute_right_endpoint_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
     return (cache.high() +
             (cache.high() >> (num_significand_bits<double>() + 1))) >>
            (64 - num_significand_bits<double>() - 1 - beta);
   }
 
-  static carrier_uint compute_round_up_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta) noexcept {
+  static auto compute_round_up_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
     return ((cache.high() >> (64 - num_significand_bits<double>() - 2 - beta)) +
             1) /
            2;
   }
 };
 
-FMT_FUNC uint128_fallback get_cached_power(int k) noexcept {
+FMT_FUNC auto get_cached_power(int k) noexcept -> uint128_fallback {
   return cache_accessor<double>::get_cached_power(k);
 }
 
 // Various integer checks
 template <typename T>
-bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept {
+auto is_left_endpoint_integer_shorter_interval(int exponent) noexcept -> bool {
   const int case_shorter_interval_left_endpoint_lower_threshold = 2;
   const int case_shorter_interval_left_endpoint_upper_threshold = 3;
   return exponent >= case_shorter_interval_left_endpoint_lower_threshold &&
@@ -1130,7 +1138,7 @@ FMT_INLINE int remove_trailing_zeros(uint32_t& n, int s = 0) noexcept {
   FMT_ASSERT(n != 0, "");
   // Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1.
   constexpr uint32_t mod_inv_5 = 0xcccccccd;
-  constexpr uint32_t mod_inv_25 = 0xc28f5c29; // = mod_inv_5 * mod_inv_5
+  constexpr uint32_t mod_inv_25 = 0xc28f5c29;  // = mod_inv_5 * mod_inv_5
 
   while (true) {
     auto q = rotr(n * mod_inv_25, 2);
@@ -1166,7 +1174,7 @@ FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept {
 
   // If n is not divisible by 10^8, work with n itself.
   constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd;
-  constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29; // = mod_inv_5 * mod_inv_5
+  constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29;  // mod_inv_5 * mod_inv_5
 
   int s = 0;
   while (true) {
@@ -1232,7 +1240,7 @@ FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept {
   return ret_value;
 }
 
-template <typename T> decimal_fp<T> to_decimal(T x) noexcept {
+template <typename T> auto to_decimal(T x) noexcept -> decimal_fp<T> {
   // Step 1: integer promotion & Schubfach multiplier calculation.
 
   using carrier_uint = typename float_info<T>::carrier_uint;
@@ -1371,15 +1379,15 @@ template <> struct formatter<detail::bigint> {
     for (auto i = n.bigits_.size(); i > 0; --i) {
       auto value = n.bigits_[i - 1u];
       if (first) {
-        out = format_to(out, FMT_STRING("{:x}"), value);
+        out = fmt::format_to(out, FMT_STRING("{:x}"), value);
         first = false;
         continue;
       }
-      out = format_to(out, FMT_STRING("{:08x}"), value);
+      out = fmt::format_to(out, FMT_STRING("{:08x}"), value);
     }
     if (n.exp_ > 0)
-      out = format_to(out, FMT_STRING("p{}"),
-                      n.exp_ * detail::bigint::bigit_bits);
+      out = fmt::format_to(out, FMT_STRING("p{}"),
+                           n.exp_ * detail::bigint::bigit_bits);
     return out;
   }
 };
@@ -1415,7 +1423,7 @@ FMT_FUNC void report_system_error(int error_code,
   report_error(format_system_error, error_code, message);
 }
 
-FMT_FUNC std::string vformat(string_view fmt, format_args args) {
+FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string {
   // Don't optimize the "{}" case to keep the binary size small and because it
   // can be better optimized in fmt::format anyway.
   auto buffer = memory_buffer();
@@ -1424,33 +1432,43 @@ FMT_FUNC std::string vformat(string_view fmt, format_args args) {
 }
 
 namespace detail {
-#ifndef _WIN32
-FMT_FUNC bool write_console(std::FILE*, string_view) { return false; }
+#if !defined(_WIN32) || defined(FMT_WINDOWS_NO_WCHAR)
+FMT_FUNC auto write_console(int, string_view) -> bool { return false; }
+FMT_FUNC auto write_console(std::FILE*, string_view) -> bool { return false; }
 #else
 using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>;
 extern "C" __declspec(dllimport) int __stdcall WriteConsoleW(  //
     void*, const void*, dword, dword*, void*);
 
-FMT_FUNC bool write_console(std::FILE* f, string_view text) {
-  auto fd = _fileno(f);
-  if (!_isatty(fd)) return false;
+FMT_FUNC bool write_console(int fd, string_view text) {
   auto u16 = utf8_to_utf16(text);
-  auto written = dword();
   return WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)), u16.c_str(),
-                       static_cast<uint32_t>(u16.size()), &written, nullptr) != 0;
+                       static_cast<dword>(u16.size()), nullptr, nullptr) != 0;
 }
 
+FMT_FUNC auto write_console(std::FILE* f, string_view text) -> bool {
+  return write_console(_fileno(f), text);
+}
+#endif
+
+#ifdef _WIN32
 // Print assuming legacy (non-Unicode) encoding.
 FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) {
   auto buffer = memory_buffer();
-  detail::vformat_to(buffer, fmt,
-                     basic_format_args<buffer_context<char>>(args));
-  fwrite_fully(buffer.data(), 1, buffer.size(), f);
+  detail::vformat_to(buffer, fmt, args);
+  fwrite_fully(buffer.data(), buffer.size(), f);
 }
 #endif
 
 FMT_FUNC void print(std::FILE* f, string_view text) {
-  if (!write_console(f, text)) fwrite_fully(text.data(), 1, text.size(), f);
+#ifdef _WIN32
+  int fd = _fileno(f);
+  if (_isatty(fd)) {
+    std::fflush(f);
+    if (write_console(fd, text)) return;
+  }
+#endif
+  fwrite_fully(text.data(), text.size(), f);
 }
 }  // namespace detail
 

wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/format.h

@@ -43,7 +43,7 @@
 #include <system_error>      // std::system_error
 
 #ifdef __cpp_lib_bit_cast
-#  include <bit>  // std::bitcast
+#  include <bit>  // std::bit_cast
 #endif
 
 #include "core.h"
@@ -93,10 +93,11 @@
 #  define FMT_NO_UNIQUE_ADDRESS
 #endif
 
-#if FMT_GCC_VERSION || defined(__clang__)
-#  define FMT_VISIBILITY(value) __attribute__((visibility(value)))
+// Visibility when compiled as a shared library/object.
+#if defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)
+#  define FMT_SO_VISIBILITY(value) FMT_VISIBILITY(value)
 #else
-#  define FMT_VISIBILITY(value)
+#  define FMT_SO_VISIBILITY(value)
 #endif
 
 #ifdef __has_builtin
@@ -152,7 +153,10 @@ FMT_END_NAMESPACE
 
 #ifndef FMT_USE_USER_DEFINED_LITERALS
 // EDG based compilers (Intel, NVIDIA, Elbrus, etc), GCC and MSVC support UDLs.
-#  if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || \
+//
+// GCC before 4.9 requires a space in `operator"" _a` which is invalid in later
+// compiler versions.
+#  if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 409 || \
        FMT_MSC_VERSION >= 1900) &&                                     \
       (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= /* UDL feature */ 480)
 #    define FMT_USE_USER_DEFINED_LITERALS 1
@@ -273,19 +277,6 @@ FMT_END_NAMESPACE
 #endif
 
 FMT_BEGIN_NAMESPACE
-
-template <typename...> struct disjunction : std::false_type {};
-template <typename P> struct disjunction<P> : P {};
-template <typename P1, typename... Pn>
-struct disjunction<P1, Pn...>
-    : conditional_t<bool(P1::value), P1, disjunction<Pn...>> {};
-
-template <typename...> struct conjunction : std::true_type {};
-template <typename P> struct conjunction<P> : P {};
-template <typename P1, typename... Pn>
-struct conjunction<P1, Pn...>
-    : conditional_t<bool(P1::value), conjunction<Pn...>, P1> {};
-
 namespace detail {
 
 FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) {
@@ -307,37 +298,6 @@ template <typename CharT, CharT... C>
 constexpr CharT string_literal<CharT, C...>::value[sizeof...(C)];
 #endif
 
-template <typename Streambuf> class formatbuf : public Streambuf {
- private:
-  using char_type = typename Streambuf::char_type;
-  using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0));
-  using int_type = typename Streambuf::int_type;
-  using traits_type = typename Streambuf::traits_type;
-
-  buffer<char_type>& buffer_;
-
- public:
-  explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {}
-
- protected:
-  // The put area is always empty. This makes the implementation simpler and has
-  // the advantage that the streambuf and the buffer are always in sync and
-  // sputc never writes into uninitialized memory. A disadvantage is that each
-  // call to sputc always results in a (virtual) call to overflow. There is no
-  // disadvantage here for sputn since this always results in a call to xsputn.
-
-  auto overflow(int_type ch) -> int_type override {
-    if (!traits_type::eq_int_type(ch, traits_type::eof()))
-      buffer_.push_back(static_cast<char_type>(ch));
-    return ch;
-  }
-
-  auto xsputn(const char_type* s, streamsize count) -> streamsize override {
-    buffer_.append(s, s + count);
-    return count;
-  }
-};
-
 // Implementation of std::bit_cast for pre-C++20.
 template <typename To, typename From, FMT_ENABLE_IF(sizeof(To) == sizeof(From))>
 FMT_CONSTEXPR20 auto bit_cast(const From& from) -> To {
@@ -373,8 +333,8 @@ class uint128_fallback {
   constexpr uint128_fallback(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {}
   constexpr uint128_fallback(uint64_t value = 0) : lo_(value), hi_(0) {}
 
-  constexpr uint64_t high() const noexcept { return hi_; }
-  constexpr uint64_t low() const noexcept { return lo_; }
+  constexpr auto high() const noexcept -> uint64_t { return hi_; }
+  constexpr auto low() const noexcept -> uint64_t { return lo_; }
 
   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
   constexpr explicit operator T() const {
@@ -450,7 +410,7 @@ class uint128_fallback {
     hi_ &= n.hi_;
   }
 
-  FMT_CONSTEXPR20 uint128_fallback& operator+=(uint64_t n) noexcept {
+  FMT_CONSTEXPR20 auto operator+=(uint64_t n) noexcept -> uint128_fallback& {
     if (is_constant_evaluated()) {
       lo_ += n;
       hi_ += (lo_ < n ? 1 : 0);
@@ -740,7 +700,7 @@ inline auto compute_width(basic_string_view<Char> s) -> size_t {
 }
 
 // Computes approximate display width of a UTF-8 string.
-FMT_CONSTEXPR inline size_t compute_width(string_view s) {
+FMT_CONSTEXPR inline auto compute_width(string_view s) -> size_t {
   size_t num_code_points = 0;
   // It is not a lambda for compatibility with C++14.
   struct count_code_points {
@@ -787,12 +747,17 @@ inline auto code_point_index(basic_string_view<Char> s, size_t n) -> size_t {
 
 // Calculates the index of the nth code point in a UTF-8 string.
 inline auto code_point_index(string_view s, size_t n) -> size_t {
-  const char* data = s.data();
-  size_t num_code_points = 0;
-  for (size_t i = 0, size = s.size(); i != size; ++i) {
-    if ((data[i] & 0xc0) != 0x80 && ++num_code_points > n) return i;
-  }
-  return s.size();
+  size_t result = s.size();
+  const char* begin = s.begin();
+  for_each_codepoint(s, [begin, &n, &result](uint32_t, string_view sv) {
+    if (n != 0) {
+      --n;
+      return true;
+    }
+    result = to_unsigned(sv.begin() - begin);
+    return false;
+  });
+  return result;
 }
 
 inline auto code_point_index(basic_string_view<char8_type> s, size_t n)
@@ -902,7 +867,7 @@ enum { inline_buffer_size = 500 };
   **Example**::
 
      auto out = fmt::memory_buffer();
-     format_to(std::back_inserter(out), "The answer is {}.", 42);
+     fmt::format_to(std::back_inserter(out), "The answer is {}.", 42);
 
   This will append the following output to the ``out`` object:
 
@@ -1018,7 +983,6 @@ class basic_memory_buffer final : public detail::buffer<T> {
   /** Increases the buffer capacity to *new_capacity*. */
   void reserve(size_t new_capacity) { this->try_reserve(new_capacity); }
 
-  // Directly append data into the buffer
   using detail::buffer<T>::append;
   template <typename ContiguousRange>
   void append(const ContiguousRange& range) {
@@ -1034,7 +998,8 @@ struct is_contiguous<basic_memory_buffer<T, SIZE, Allocator>> : std::true_type {
 
 FMT_END_EXPORT
 namespace detail {
-FMT_API bool write_console(std::FILE* f, string_view text);
+FMT_API auto write_console(int fd, string_view text) -> bool;
+FMT_API auto write_console(std::FILE* f, string_view text) -> bool;
 FMT_API void print(std::FILE*, string_view);
 }  // namespace detail
 
@@ -1046,7 +1011,7 @@ FMT_BEGIN_EXPORT
 #endif
 
 /** An error reported from a formatting function. */
-class FMT_VISIBILITY("default") format_error : public std::runtime_error {
+class FMT_SO_VISIBILITY("default") format_error : public std::runtime_error {
  public:
   using std::runtime_error::runtime_error;
 };
@@ -1153,13 +1118,13 @@ using uint32_or_64_or_128_t =
 template <typename T>
 using uint64_or_128_t = conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>;
 
-#define FMT_POWERS_OF_10(factor)                                             \
-  factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, \
-      (factor)*1000000, (factor)*10000000, (factor)*100000000,               \
-      (factor)*1000000000
+#define FMT_POWERS_OF_10(factor)                                  \
+  factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \
+      (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \
+      (factor) * 100000000, (factor) * 1000000000
 
 // Converts value in the range [0, 100) to a string.
-constexpr const char* digits2(size_t value) {
+constexpr auto digits2(size_t value) -> const char* {
   // GCC generates slightly better code when value is pointer-size.
   return &"0001020304050607080910111213141516171819"
          "2021222324252627282930313233343536373839"
@@ -1169,7 +1134,7 @@ constexpr const char* digits2(size_t value) {
 }
 
 // Sign is a template parameter to workaround a bug in gcc 4.8.
-template <typename Char, typename Sign> constexpr Char sign(Sign s) {
+template <typename Char, typename Sign> constexpr auto sign(Sign s) -> Char {
 #if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 604
   static_assert(std::is_same<Sign, sign_t>::value, "");
 #endif
@@ -1401,7 +1366,7 @@ FMT_CONSTEXPR inline auto format_uint(It out, UInt value, int num_digits,
     return out;
   }
   // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
-  char buffer[num_bits<UInt>() / BASE_BITS + 1];
+  char buffer[num_bits<UInt>() / BASE_BITS + 1] = {};
   format_uint<BASE_BITS>(buffer, value, num_digits, upper);
   return detail::copy_str_noinline<Char>(buffer, buffer + num_digits, out);
 }
@@ -1437,22 +1402,23 @@ template <typename WChar, typename Buffer = memory_buffer> class to_utf8 {
                                                       : "invalid utf32"));
   }
   operator string_view() const { return string_view(&buffer_[0], size()); }
-  size_t size() const { return buffer_.size() - 1; }
-  const char* c_str() const { return &buffer_[0]; }
-  std::string str() const { return std::string(&buffer_[0], size()); }
+  auto size() const -> size_t { return buffer_.size() - 1; }
+  auto c_str() const -> const char* { return &buffer_[0]; }
+  auto str() const -> std::string { return std::string(&buffer_[0], size()); }
 
   // Performs conversion returning a bool instead of throwing exception on
   // conversion error. This method may still throw in case of memory allocation
   // error.
-  bool convert(basic_string_view<WChar> s,
-               to_utf8_error_policy policy = to_utf8_error_policy::abort) {
+  auto convert(basic_string_view<WChar> s,
+               to_utf8_error_policy policy = to_utf8_error_policy::abort)
+      -> bool {
     if (!convert(buffer_, s, policy)) return false;
     buffer_.push_back(0);
     return true;
   }
-  static bool convert(
-      Buffer& buf, basic_string_view<WChar> s,
-      to_utf8_error_policy policy = to_utf8_error_policy::abort) {
+  static auto convert(Buffer& buf, basic_string_view<WChar> s,
+                      to_utf8_error_policy policy = to_utf8_error_policy::abort)
+      -> bool {
     for (auto p = s.begin(); p != s.end(); ++p) {
       uint32_t c = static_cast<uint32_t>(*p);
       if (sizeof(WChar) == 2 && c >= 0xd800 && c <= 0xdfff) {
@@ -1488,7 +1454,7 @@ template <typename WChar, typename Buffer = memory_buffer> class to_utf8 {
 };
 
 // Computes 128-bit result of multiplication of two 64-bit unsigned integers.
-inline uint128_fallback umul128(uint64_t x, uint64_t y) noexcept {
+inline auto umul128(uint64_t x, uint64_t y) noexcept -> uint128_fallback {
 #if FMT_USE_INT128
   auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
   return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)};
@@ -1519,19 +1485,19 @@ inline uint128_fallback umul128(uint64_t x, uint64_t y) noexcept {
 namespace dragonbox {
 // Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from
 // https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1.
-inline int floor_log10_pow2(int e) noexcept {
+inline auto floor_log10_pow2(int e) noexcept -> int {
   FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent");
   static_assert((-1 >> 1) == -1, "right shift is not arithmetic");
   return (e * 315653) >> 20;
 }
 
-inline int floor_log2_pow10(int e) noexcept {
+inline auto floor_log2_pow10(int e) noexcept -> int {
   FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
   return (e * 1741647) >> 19;
 }
 
 // Computes upper 64 bits of multiplication of two 64-bit unsigned integers.
-inline uint64_t umul128_upper64(uint64_t x, uint64_t y) noexcept {
+inline auto umul128_upper64(uint64_t x, uint64_t y) noexcept -> uint64_t {
 #if FMT_USE_INT128
   auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
   return static_cast<uint64_t>(p >> 64);
@@ -1544,14 +1510,14 @@ inline uint64_t umul128_upper64(uint64_t x, uint64_t y) noexcept {
 
 // Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a
 // 128-bit unsigned integer.
-inline uint128_fallback umul192_upper128(uint64_t x,
-                                         uint128_fallback y) noexcept {
+inline auto umul192_upper128(uint64_t x, uint128_fallback y) noexcept
+    -> uint128_fallback {
   uint128_fallback r = umul128(x, y.high());
   r += umul128_upper64(x, y.low());
   return r;
 }
 
-FMT_API uint128_fallback get_cached_power(int k) noexcept;
+FMT_API auto get_cached_power(int k) noexcept -> uint128_fallback;
 
 // Type-specific information that Dragonbox uses.
 template <typename T, typename Enable = void> struct float_info;
@@ -1605,14 +1571,14 @@ template <typename T> FMT_API auto to_decimal(T x) noexcept -> decimal_fp<T>;
 }  // namespace dragonbox
 
 // Returns true iff Float has the implicit bit which is not stored.
-template <typename Float> constexpr bool has_implicit_bit() {
+template <typename Float> constexpr auto has_implicit_bit() -> bool {
   // An 80-bit FP number has a 64-bit significand an no implicit bit.
   return std::numeric_limits<Float>::digits != 64;
 }
 
 // Returns the number of significand bits stored in Float. The implicit bit is
 // not counted since it is not stored.
-template <typename Float> constexpr int num_significand_bits() {
+template <typename Float> constexpr auto num_significand_bits() -> int {
   // std::numeric_limits may not support __float128.
   return is_float128<Float>() ? 112
                               : (std::numeric_limits<Float>::digits -
@@ -1705,7 +1671,7 @@ using fp = basic_fp<unsigned long long>;
 
 // Normalizes the value converted from double and multiplied by (1 << SHIFT).
 template <int SHIFT = 0, typename F>
-FMT_CONSTEXPR basic_fp<F> normalize(basic_fp<F> value) {
+FMT_CONSTEXPR auto normalize(basic_fp<F> value) -> basic_fp<F> {
   // Handle subnormals.
   const auto implicit_bit = F(1) << num_significand_bits<double>();
   const auto shifted_implicit_bit = implicit_bit << SHIFT;
@@ -1722,7 +1688,7 @@ FMT_CONSTEXPR basic_fp<F> normalize(basic_fp<F> value) {
 }
 
 // Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.
-FMT_CONSTEXPR inline uint64_t multiply(uint64_t lhs, uint64_t rhs) {
+FMT_CONSTEXPR inline auto multiply(uint64_t lhs, uint64_t rhs) -> uint64_t {
 #if FMT_USE_INT128
   auto product = static_cast<__uint128_t>(lhs) * rhs;
   auto f = static_cast<uint64_t>(product >> 64);
@@ -1739,33 +1705,10 @@ FMT_CONSTEXPR inline uint64_t multiply(uint64_t lhs, uint64_t rhs) {
 #endif
 }
 
-FMT_CONSTEXPR inline fp operator*(fp x, fp y) {
+FMT_CONSTEXPR inline auto operator*(fp x, fp y) -> fp {
   return {multiply(x.f, y.f), x.e + y.e + 64};
 }
 
-template <typename T = void> struct basic_data {
-  // For checking rounding thresholds.
-  // The kth entry is chosen to be the smallest integer such that the
-  // upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k.
-  static constexpr uint32_t fractional_part_rounding_thresholds[8] = {
-      2576980378U,  // ceil(2^31 + 2^32/10^1)
-      2190433321U,  // ceil(2^31 + 2^32/10^2)
-      2151778616U,  // ceil(2^31 + 2^32/10^3)
-      2147913145U,  // ceil(2^31 + 2^32/10^4)
-      2147526598U,  // ceil(2^31 + 2^32/10^5)
-      2147487943U,  // ceil(2^31 + 2^32/10^6)
-      2147484078U,  // ceil(2^31 + 2^32/10^7)
-      2147483691U   // ceil(2^31 + 2^32/10^8)
-  };
-};
-// This is a struct rather than an alias to avoid shadowing warnings in gcc.
-struct data : basic_data<> {};
-
-#if FMT_CPLUSPLUS < 201703L
-template <typename T>
-constexpr uint32_t basic_data<T>::fractional_part_rounding_thresholds[];
-#endif
-
 template <typename T, bool doublish = num_bits<T>() == num_bits<double>()>
 using convert_float_result =
     conditional_t<std::is_same<T, float>::value || doublish, double, T>;
@@ -1984,11 +1927,13 @@ auto write_escaped_string(OutputIt out, basic_string_view<Char> str)
 
 template <typename Char, typename OutputIt>
 auto write_escaped_char(OutputIt out, Char v) -> OutputIt {
+  Char v_array[1] = {v};
   *out++ = static_cast<Char>('\'');
   if ((needs_escape(static_cast<uint32_t>(v)) && v != static_cast<Char>('"')) ||
       v == static_cast<Char>('\'')) {
-    out = write_escaped_cp(
-        out, find_escape_result<Char>{&v, &v + 1, static_cast<uint32_t>(v)});
+    out = write_escaped_cp(out,
+                           find_escape_result<Char>{v_array, v_array + 1,
+                                                    static_cast<uint32_t>(v)});
   } else {
     *out++ = v;
   }
@@ -2077,10 +2022,10 @@ template <typename Char> class digit_grouping {
     std::string::const_iterator group;
     int pos;
   };
-  next_state initial_state() const { return {grouping_.begin(), 0}; }
+  auto initial_state() const -> next_state { return {grouping_.begin(), 0}; }
 
   // Returns the next digit group separator position.
-  int next(next_state& state) const {
+  auto next(next_state& state) const -> int {
     if (thousands_sep_.empty()) return max_value<int>();
     if (state.group == grouping_.end()) return state.pos += grouping_.back();
     if (*state.group <= 0 || *state.group == max_value<char>())
@@ -2099,9 +2044,9 @@ template <typename Char> class digit_grouping {
   digit_grouping(std::string grouping, std::basic_string<Char> sep)
       : grouping_(std::move(grouping)), thousands_sep_(std::move(sep)) {}
 
-  bool has_separator() const { return !thousands_sep_.empty(); }
+  auto has_separator() const -> bool { return !thousands_sep_.empty(); }
 
-  int count_separators(int num_digits) const {
+  auto count_separators(int num_digits) const -> int {
     int count = 0;
     auto state = initial_state();
     while (num_digits > next(state)) ++count;
@@ -2110,7 +2055,7 @@ template <typename Char> class digit_grouping {
 
   // Applies grouping to digits and write the output to out.
   template <typename Out, typename C>
-  Out apply(Out out, basic_string_view<C> digits) const {
+  auto apply(Out out, basic_string_view<C> digits) const -> Out {
     auto num_digits = static_cast<int>(digits.size());
     auto separators = basic_memory_buffer<int>();
     separators.push_back(0);
@@ -2133,24 +2078,66 @@ template <typename Char> class digit_grouping {
   }
 };
 
+FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) {
+  prefix |= prefix != 0 ? value << 8 : value;
+  prefix += (1u + (value > 0xff ? 1 : 0)) << 24;
+}
+
 // Writes a decimal integer with digit grouping.
 template <typename OutputIt, typename UInt, typename Char>
 auto write_int(OutputIt out, UInt value, unsigned prefix,
                const format_specs<Char>& specs,
                const digit_grouping<Char>& grouping) -> OutputIt {
   static_assert(std::is_same<uint64_or_128_t<UInt>, UInt>::value, "");
-  int num_digits = count_digits(value);
-  char digits[40];
-  format_decimal(digits, value, num_digits);
-  unsigned size = to_unsigned((prefix != 0 ? 1 : 0) + num_digits +
-                              grouping.count_separators(num_digits));
+  int num_digits = 0;
+  auto buffer = memory_buffer();
+  switch (specs.type) {
+  case presentation_type::none:
+  case presentation_type::dec: {
+    num_digits = count_digits(value);
+    format_decimal<char>(appender(buffer), value, num_digits);
+    break;
+  }
+  case presentation_type::hex_lower:
+  case presentation_type::hex_upper: {
+    bool upper = specs.type == presentation_type::hex_upper;
+    if (specs.alt)
+      prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0');
+    num_digits = count_digits<4>(value);
+    format_uint<4, char>(appender(buffer), value, num_digits, upper);
+    break;
+  }
+  case presentation_type::bin_lower:
+  case presentation_type::bin_upper: {
+    bool upper = specs.type == presentation_type::bin_upper;
+    if (specs.alt)
+      prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0');
+    num_digits = count_digits<1>(value);
+    format_uint<1, char>(appender(buffer), value, num_digits);
+    break;
+  }
+  case presentation_type::oct: {
+    num_digits = count_digits<3>(value);
+    // Octal prefix '0' is counted as a digit, so only add it if precision
+    // is not greater than the number of digits.
+    if (specs.alt && specs.precision <= num_digits && value != 0)
+      prefix_append(prefix, '0');
+    format_uint<3, char>(appender(buffer), value, num_digits);
+    break;
+  }
+  case presentation_type::chr:
+    return write_char(out, static_cast<Char>(value), specs);
+  default:
+    throw_format_error("invalid format specifier");
+  }
+
+  unsigned size = (prefix != 0 ? prefix >> 24 : 0) + to_unsigned(num_digits) +
+                  to_unsigned(grouping.count_separators(num_digits));
   return write_padded<align::right>(
       out, specs, size, size, [&](reserve_iterator<OutputIt> it) {
-        if (prefix != 0) {
-          char sign = static_cast<char>(prefix);
-          *it++ = static_cast<Char>(sign);
-        }
-        return grouping.apply(it, string_view(digits, to_unsigned(num_digits)));
+        for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
+          *it++ = static_cast<Char>(p & 0xff);
+        return grouping.apply(it, string_view(buffer.data(), buffer.size()));
       });
 }
 
@@ -2163,11 +2150,6 @@ inline auto write_loc(OutputIt, loc_value, const format_specs<Char>&,
   return false;
 }
 
-FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) {
-  prefix |= prefix != 0 ? value << 8 : value;
-  prefix += (1u + (value > 0xff ? 1 : 0)) << 24;
-}
-
 template <typename UInt> struct write_int_arg {
   UInt abs_value;
   unsigned prefix;
@@ -2314,25 +2296,25 @@ class counting_iterator {
 
   FMT_CONSTEXPR counting_iterator() : count_(0) {}
 
-  FMT_CONSTEXPR size_t count() const { return count_; }
+  FMT_CONSTEXPR auto count() const -> size_t { return count_; }
 
-  FMT_CONSTEXPR counting_iterator& operator++() {
+  FMT_CONSTEXPR auto operator++() -> counting_iterator& {
     ++count_;
     return *this;
   }
-  FMT_CONSTEXPR counting_iterator operator++(int) {
+  FMT_CONSTEXPR auto operator++(int) -> counting_iterator {
     auto it = *this;
     ++*this;
     return it;
   }
 
-  FMT_CONSTEXPR friend counting_iterator operator+(counting_iterator it,
-                                                   difference_type n) {
+  FMT_CONSTEXPR friend auto operator+(counting_iterator it, difference_type n)
+      -> counting_iterator {
     it.count_ += static_cast<size_t>(n);
     return it;
   }
 
-  FMT_CONSTEXPR value_type operator*() const { return {}; }
+  FMT_CONSTEXPR auto operator*() const -> value_type { return {}; }
 };
 
 template <typename Char, typename OutputIt>
@@ -2367,9 +2349,10 @@ template <typename Char, typename OutputIt>
 FMT_CONSTEXPR auto write(OutputIt out, const Char* s,
                          const format_specs<Char>& specs, locale_ref)
     -> OutputIt {
-  return specs.type != presentation_type::pointer
-             ? write(out, basic_string_view<Char>(s), specs, {})
-             : write_ptr<Char>(out, bit_cast<uintptr_t>(s), &specs);
+  if (specs.type == presentation_type::pointer)
+    return write_ptr<Char>(out, bit_cast<uintptr_t>(s), &specs);
+  if (!s) throw_format_error("string pointer is null");
+  return write(out, basic_string_view<Char>(s), specs, {});
 }
 
 template <typename Char, typename OutputIt, typename T,
@@ -2455,9 +2438,8 @@ struct float_specs {
   bool showpoint : 1;
 };
 
-template <typename ErrorHandler = error_handler, typename Char>
-FMT_CONSTEXPR auto parse_float_type_spec(const format_specs<Char>& specs,
-                                         ErrorHandler&& eh = {})
+template <typename Char>
+FMT_CONSTEXPR auto parse_float_type_spec(const format_specs<Char>& specs)
     -> float_specs {
   auto result = float_specs();
   result.showpoint = specs.alt;
@@ -2493,7 +2475,7 @@ FMT_CONSTEXPR auto parse_float_type_spec(const format_specs<Char>& specs,
     result.format = float_format::hex;
     break;
   default:
-    eh.on_error("invalid format specifier");
+    throw_format_error("invalid format specifier");
     break;
   }
   return result;
@@ -2732,12 +2714,12 @@ template <typename Char> class fallback_digit_grouping {
  public:
   constexpr fallback_digit_grouping(locale_ref, bool) {}
 
-  constexpr bool has_separator() const { return false; }
+  constexpr auto has_separator() const -> bool { return false; }
 
-  constexpr int count_separators(int) const { return 0; }
+  constexpr auto count_separators(int) const -> int { return 0; }
 
   template <typename Out, typename C>
-  constexpr Out apply(Out out, basic_string_view<C>) const {
+  constexpr auto apply(Out out, basic_string_view<C>) const -> Out {
     return out;
   }
 };
@@ -2756,7 +2738,7 @@ FMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& f,
   }
 }
 
-template <typename T> constexpr bool isnan(T value) {
+template <typename T> constexpr auto isnan(T value) -> bool {
   return !(value >= value);  // std::isnan doesn't support __float128.
 }
 
@@ -2769,14 +2751,14 @@ struct has_isfinite<T, enable_if_t<sizeof(std::isfinite(T())) != 0>>
 
 template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value&&
                                         has_isfinite<T>::value)>
-FMT_CONSTEXPR20 bool isfinite(T value) {
+FMT_CONSTEXPR20 auto isfinite(T value) -> bool {
   constexpr T inf = T(std::numeric_limits<double>::infinity());
   if (is_constant_evaluated())
     return !detail::isnan(value) && value < inf && value > -inf;
   return std::isfinite(value);
 }
 template <typename T, FMT_ENABLE_IF(!has_isfinite<T>::value)>
-FMT_CONSTEXPR bool isfinite(T value) {
+FMT_CONSTEXPR auto isfinite(T value) -> bool {
   T inf = T(std::numeric_limits<double>::infinity());
   // std::isfinite doesn't support __float128.
   return !detail::isnan(value) && value < inf && value > -inf;
@@ -2813,10 +2795,10 @@ class bigint {
   basic_memory_buffer<bigit, bigits_capacity> bigits_;
   int exp_;
 
-  FMT_CONSTEXPR20 bigit operator[](int index) const {
+  FMT_CONSTEXPR20 auto operator[](int index) const -> bigit {
     return bigits_[to_unsigned(index)];
   }
-  FMT_CONSTEXPR20 bigit& operator[](int index) {
+  FMT_CONSTEXPR20 auto operator[](int index) -> bigit& {
     return bigits_[to_unsigned(index)];
   }
 
@@ -2912,11 +2894,11 @@ class bigint {
     assign(uint64_or_128_t<Int>(n));
   }
 
-  FMT_CONSTEXPR20 int num_bigits() const {
+  FMT_CONSTEXPR20 auto num_bigits() const -> int {
     return static_cast<int>(bigits_.size()) + exp_;
   }
 
-  FMT_NOINLINE FMT_CONSTEXPR20 bigint& operator<<=(int shift) {
+  FMT_NOINLINE FMT_CONSTEXPR20 auto operator<<=(int shift) -> bigint& {
     FMT_ASSERT(shift >= 0, "");
     exp_ += shift / bigit_bits;
     shift %= bigit_bits;
@@ -2931,13 +2913,15 @@ class bigint {
     return *this;
   }
 
-  template <typename Int> FMT_CONSTEXPR20 bigint& operator*=(Int value) {
+  template <typename Int>
+  FMT_CONSTEXPR20 auto operator*=(Int value) -> bigint& {
     FMT_ASSERT(value > 0, "");
     multiply(uint32_or_64_or_128_t<Int>(value));
     return *this;
   }
 
-  friend FMT_CONSTEXPR20 int compare(const bigint& lhs, const bigint& rhs) {
+  friend FMT_CONSTEXPR20 auto compare(const bigint& lhs, const bigint& rhs)
+      -> int {
     int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();
     if (num_lhs_bigits != num_rhs_bigits)
       return num_lhs_bigits > num_rhs_bigits ? 1 : -1;
@@ -2954,8 +2938,9 @@ class bigint {
   }
 
   // Returns compare(lhs1 + lhs2, rhs).
-  friend FMT_CONSTEXPR20 int add_compare(const bigint& lhs1, const bigint& lhs2,
-                                         const bigint& rhs) {
+  friend FMT_CONSTEXPR20 auto add_compare(const bigint& lhs1,
+                                          const bigint& lhs2, const bigint& rhs)
+      -> int {
     auto minimum = [](int a, int b) { return a < b ? a : b; };
     auto maximum = [](int a, int b) { return a > b ? a : b; };
     int max_lhs_bigits = maximum(lhs1.num_bigits(), lhs2.num_bigits());
@@ -3036,13 +3021,13 @@ class bigint {
     bigits_.resize(to_unsigned(num_bigits + exp_difference));
     for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
       bigits_[j] = bigits_[i];
-    std::uninitialized_fill_n(bigits_.data(), exp_difference, 0);
+    std::uninitialized_fill_n(bigits_.data(), exp_difference, 0u);
     exp_ -= exp_difference;
   }
 
   // Divides this bignum by divisor, assigning the remainder to this and
   // returning the quotient.
-  FMT_CONSTEXPR20 int divmod_assign(const bigint& divisor) {
+  FMT_CONSTEXPR20 auto divmod_assign(const bigint& divisor) -> int {
     FMT_ASSERT(this != &divisor, "");
     if (compare(*this, divisor) < 0) return 0;
     FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
@@ -3185,8 +3170,10 @@ FMT_CONSTEXPR20 inline void format_dragon(basic_fp<uint128_t> value,
       }
       if (buf[0] == overflow) {
         buf[0] = '1';
-        if ((flags & dragon::fixed) != 0) buf.push_back('0');
-        else ++exp10;
+        if ((flags & dragon::fixed) != 0)
+          buf.push_back('0');
+        else
+          ++exp10;
       }
       return;
     }
@@ -3283,6 +3270,17 @@ FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision,
   format_hexfloat(static_cast<double>(value), precision, specs, buf);
 }
 
+constexpr auto fractional_part_rounding_thresholds(int index) -> uint32_t {
+  // For checking rounding thresholds.
+  // The kth entry is chosen to be the smallest integer such that the
+  // upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k.
+  // It is equal to ceil(2^31 + 2^32/10^(k + 1)).
+  // These are stored in a string literal because we cannot have static arrays
+  // in constexpr functions and non-static ones are poorly optimized.
+  return U"\x9999999a\x828f5c29\x80418938\x80068db9\x8000a7c6\x800010c7"
+         U"\x800001ae\x8000002b"[index];
+}
+
 template <typename Float>
 FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs,
                                   buffer<char>& buf) -> int {
@@ -3487,12 +3485,12 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs,
           //    fractional part is strictly larger than 1/2.
           if (precision < 9) {
             uint32_t fractional_part = static_cast<uint32_t>(prod);
-            should_round_up = fractional_part >=
-                                  data::fractional_part_rounding_thresholds
-                                      [8 - number_of_digits_to_print] ||
-                              ((fractional_part >> 31) &
-                               ((digits & 1) | (second_third_subsegments != 0) |
-                                has_more_segments)) != 0;
+            should_round_up =
+                fractional_part >= fractional_part_rounding_thresholds(
+                                       8 - number_of_digits_to_print) ||
+                ((fractional_part >> 31) &
+                 ((digits & 1) | (second_third_subsegments != 0) |
+                  has_more_segments)) != 0;
           }
           // Rounding at the subsegment boundary.
           // In this case, the fractional part is at least 1/2 if and only if
@@ -3527,12 +3525,12 @@ FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs,
             // of 19 digits, so in this case the third segment should be
             // consisting of a genuine digit from the input.
             uint32_t fractional_part = static_cast<uint32_t>(prod);
-            should_round_up = fractional_part >=
-                                  data::fractional_part_rounding_thresholds
-                                      [8 - number_of_digits_to_print] ||
-                              ((fractional_part >> 31) &
-                               ((digits & 1) | (third_subsegment != 0) |
-                                has_more_segments)) != 0;
+            should_round_up =
+                fractional_part >= fractional_part_rounding_thresholds(
+                                       8 - number_of_digits_to_print) ||
+                ((fractional_part >> 31) &
+                 ((digits & 1) | (third_subsegment != 0) |
+                  has_more_segments)) != 0;
           }
           // Rounding at the subsegment boundary.
           else {
@@ -3764,8 +3762,11 @@ template <typename Char, typename OutputIt, typename T,
 FMT_CONSTEXPR auto write(OutputIt out, const T& value)
     -> enable_if_t<mapped_type_constant<T, Context>::value == type::custom_type,
                    OutputIt> {
+  auto formatter = typename Context::template formatter_type<T>();
+  auto parse_ctx = typename Context::parse_context_type({});
+  formatter.parse(parse_ctx);
   auto ctx = Context(out, {}, {});
-  return typename Context::template formatter_type<T>().format(value, ctx);
+  return formatter.format(value, ctx);
 }
 
 // An argument visitor that formats the argument and writes it via the output
@@ -3808,62 +3809,39 @@ template <typename Char> struct arg_formatter {
   }
 };
 
-template <typename Char> struct custom_formatter {
-  basic_format_parse_context<Char>& parse_ctx;
-  buffer_context<Char>& ctx;
-
-  void operator()(
-      typename basic_format_arg<buffer_context<Char>>::handle h) const {
-    h.format(parse_ctx, ctx);
-  }
-  template <typename T> void operator()(T) const {}
-};
-
-template <typename ErrorHandler> class width_checker {
- public:
-  explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {}
-
+struct width_checker {
   template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
   FMT_CONSTEXPR auto operator()(T value) -> unsigned long long {
-    if (is_negative(value)) handler_.on_error("negative width");
+    if (is_negative(value)) throw_format_error("negative width");
     return static_cast<unsigned long long>(value);
   }
 
   template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
   FMT_CONSTEXPR auto operator()(T) -> unsigned long long {
-    handler_.on_error("width is not integer");
+    throw_format_error("width is not integer");
     return 0;
   }
-
- private:
-  ErrorHandler& handler_;
 };
 
-template <typename ErrorHandler> class precision_checker {
- public:
-  explicit FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {}
-
+struct precision_checker {
   template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
   FMT_CONSTEXPR auto operator()(T value) -> unsigned long long {
-    if (is_negative(value)) handler_.on_error("negative precision");
+    if (is_negative(value)) throw_format_error("negative precision");
     return static_cast<unsigned long long>(value);
   }
 
   template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
   FMT_CONSTEXPR auto operator()(T) -> unsigned long long {
-    handler_.on_error("precision is not integer");
+    throw_format_error("precision is not integer");
     return 0;
   }
-
- private:
-  ErrorHandler& handler_;
 };
 
-template <template <typename> class Handler, typename FormatArg,
-          typename ErrorHandler>
-FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg, ErrorHandler eh) -> int {
-  unsigned long long value = visit_format_arg(Handler<ErrorHandler>(eh), arg);
-  if (value > to_unsigned(max_value<int>())) eh.on_error("number is too big");
+template <typename Handler, typename FormatArg>
+FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg) -> int {
+  unsigned long long value = visit_format_arg(Handler(), arg);
+  if (value > to_unsigned(max_value<int>()))
+    throw_format_error("number is too big");
   return static_cast<int>(value);
 }
 
@@ -3874,7 +3852,7 @@ FMT_CONSTEXPR auto get_arg(Context& ctx, ID id) -> decltype(ctx.arg(id)) {
   return arg;
 }
 
-template <template <typename> class Handler, typename Context>
+template <typename Handler, typename Context>
 FMT_CONSTEXPR void handle_dynamic_spec(int& value,
                                        arg_ref<typename Context::char_type> ref,
                                        Context& ctx) {
@@ -3882,12 +3860,10 @@ FMT_CONSTEXPR void handle_dynamic_spec(int& value,
   case arg_id_kind::none:
     break;
   case arg_id_kind::index:
-    value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.index),
-                                              ctx.error_handler());
+    value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.index));
     break;
   case arg_id_kind::name:
-    value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.name),
-                                              ctx.error_handler());
+    value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.name));
     break;
   }
 }
@@ -4059,12 +4035,10 @@ class format_int {
 
 template <typename T, typename Char>
 struct formatter<T, Char, enable_if_t<detail::has_format_as<T>::value>>
-    : private formatter<detail::format_as_t<T>, Char> {
-  using base = formatter<detail::format_as_t<T>, Char>;
-  using base::parse;
-
+    : formatter<detail::format_as_t<T>, Char> {
   template <typename FormatContext>
   auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) {
+    using base = formatter<detail::format_as_t<T>, Char>;
     return base::format(format_as(value), ctx);
   }
 };
@@ -4205,6 +4179,59 @@ template <typename T> struct formatter<group_digits_view<T>> : formatter<T> {
   }
 };
 
+template <typename T> struct nested_view {
+  const formatter<T>* fmt;
+  const T* value;
+};
+
+template <typename T> struct formatter<nested_view<T>> {
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* {
+    return ctx.begin();
+  }
+  auto format(nested_view<T> view, format_context& ctx) const
+      -> decltype(ctx.out()) {
+    return view.fmt->format(*view.value, ctx);
+  }
+};
+
+template <typename T> struct nested_formatter {
+ private:
+  int width_;
+  detail::fill_t<char> fill_;
+  align_t align_ : 4;
+  formatter<T> formatter_;
+
+ public:
+  constexpr nested_formatter() : width_(0), align_(align_t::none) {}
+
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* {
+    auto specs = detail::dynamic_format_specs<char>();
+    auto it = parse_format_specs(ctx.begin(), ctx.end(), specs, ctx,
+                                 detail::type::none_type);
+    width_ = specs.width;
+    fill_ = specs.fill;
+    align_ = specs.align;
+    ctx.advance_to(it);
+    return formatter_.parse(ctx);
+  }
+
+  template <typename F>
+  auto write_padded(format_context& ctx, F write) const -> decltype(ctx.out()) {
+    if (width_ == 0) return write(ctx.out());
+    auto buf = memory_buffer();
+    write(std::back_inserter(buf));
+    auto specs = format_specs<>();
+    specs.width = width_;
+    specs.fill = fill_;
+    specs.align = align_;
+    return detail::write(ctx.out(), string_view(buf.data(), buf.size()), specs);
+  }
+
+  auto nested(const T& value) const -> nested_view<T> {
+    return nested_view<T>{&formatter_, &value};
+  }
+};
+
 // DEPRECATED! join_view will be moved to ranges.h.
 template <typename It, typename Sentinel, typename Char = char>
 struct join_view : detail::view {
@@ -4336,7 +4363,7 @@ void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt,
   auto out = buffer_appender<Char>(buf);
   if (fmt.size() == 2 && equal2(fmt.data(), "{}")) {
     auto arg = args.get(0);
-    if (!arg) error_handler().on_error("argument not found");
+    if (!arg) throw_format_error("argument not found");
     visit_format_arg(default_arg_formatter<Char>{out, args, loc}, arg);
     return;
   }
@@ -4363,7 +4390,7 @@ void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt,
     }
     FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int {
       int arg_id = context.arg_id(id);
-      if (arg_id < 0) on_error("argument not found");
+      if (arg_id < 0) throw_format_error("argument not found");
       return arg_id;
     }
 
@@ -4378,11 +4405,9 @@ void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt,
     auto on_format_specs(int id, const Char* begin, const Char* end)
         -> const Char* {
       auto arg = get_arg(context, id);
-      if (arg.type() == type::custom_type) {
-        parse_context.advance_to(begin);
-        visit_format_arg(custom_formatter<Char>{parse_context, context}, arg);
+      // Not using a visitor for custom types gives better codegen.
+      if (arg.format_custom(begin, parse_context, context))
         return parse_context.begin();
-      }
       auto specs = detail::dynamic_format_specs<Char>();
       begin = parse_format_specs(begin, end, specs, parse_context, arg.type());
       detail::handle_dynamic_spec<detail::width_checker>(
@@ -4390,7 +4415,7 @@ void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt,
       detail::handle_dynamic_spec<detail::precision_checker>(
           specs.precision, specs.precision_ref, context);
       if (begin == end || *begin != '}')
-        on_error("missing '}' in format string");
+        throw_format_error("missing '}' in format string");
       auto f = arg_formatter<Char>{context.out(), specs, context.locale()};
       context.advance_to(visit_format_arg(f, arg));
       return begin;
@@ -4433,7 +4458,7 @@ template <detail_exported::fixed_string Str> constexpr auto operator""_a() {
   return detail::udl_arg<char_t, sizeof(Str.data) / sizeof(char_t), Str>();
 }
 #  else
-constexpr auto operator"" _a(const char* s, size_t) -> detail::udl_arg<char> {
+constexpr auto operator""_a(const char* s, size_t) -> detail::udl_arg<char> {
   return {s};
 }
 #  endif
@@ -4493,16 +4518,16 @@ formatter<T, Char,
                       detail::type::custom_type>>::format(const T& val,
                                                           FormatContext& ctx)
     const -> decltype(ctx.out()) {
-  if (specs_.width_ref.kind != detail::arg_id_kind::none ||
-      specs_.precision_ref.kind != detail::arg_id_kind::none) {
-    auto specs = specs_;
-    detail::handle_dynamic_spec<detail::width_checker>(specs.width,
-                                                       specs.width_ref, ctx);
-    detail::handle_dynamic_spec<detail::precision_checker>(
-        specs.precision, specs.precision_ref, ctx);
-    return detail::write<Char>(ctx.out(), val, specs, ctx.locale());
+  if (specs_.width_ref.kind == detail::arg_id_kind::none &&
+      specs_.precision_ref.kind == detail::arg_id_kind::none) {
+    return detail::write<Char>(ctx.out(), val, specs_, ctx.locale());
   }
-  return detail::write<Char>(ctx.out(), val, specs_, ctx.locale());
+  auto specs = specs_;
+  detail::handle_dynamic_spec<detail::width_checker>(specs.width,
+                                                     specs.width_ref, ctx);
+  detail::handle_dynamic_spec<detail::precision_checker>(
+      specs.precision, specs.precision_ref, ctx);
+  return detail::write<Char>(ctx.out(), val, specs, ctx.locale());
 }
 
 FMT_END_NAMESPACE

wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/os.h

@@ -13,12 +13,14 @@
 #include <cstdio>
 #include <system_error>  // std::system_error
 
-#if defined __APPLE__ || defined(__FreeBSD__)
-#  include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
-#endif
-
 #include "format.h"
 
+#if defined __APPLE__ || defined(__FreeBSD__)
+#  if FMT_HAS_INCLUDE(<xlocale.h>)
+#    include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
+#  endif
+#endif
+
 #ifndef FMT_USE_FCNTL
 // UWP doesn't provide _pipe.
 #  if FMT_HAS_INCLUDE("winapifamily.h")
@@ -46,6 +48,7 @@
 
 // Calls to system functions are wrapped in FMT_SYSTEM for testability.
 #ifdef FMT_SYSTEM
+#  define FMT_HAS_SYSTEM
 #  define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
 #else
 #  define FMT_SYSTEM(call) ::call
@@ -114,7 +117,7 @@ template <typename Char> class basic_cstring_view {
   basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {}
 
   /** Returns the pointer to a C string. */
-  const Char* c_str() const { return data_; }
+  auto c_str() const -> const Char* { return data_; }
 };
 
 using cstring_view = basic_cstring_view<char>;
@@ -169,7 +172,7 @@ std::system_error windows_error(int error_code, string_view message,
 // Can be used to report errors from destructors.
 FMT_API void report_windows_error(int error_code, const char* message) noexcept;
 #else
-inline const std::error_category& system_category() noexcept {
+inline auto system_category() noexcept -> const std::error_category& {
   return std::system_category();
 }
 #endif  // _WIN32
@@ -206,7 +209,7 @@ class buffered_file {
     other.file_ = nullptr;
   }
 
-  buffered_file& operator=(buffered_file&& other) {
+  auto operator=(buffered_file&& other) -> buffered_file& {
     close();
     file_ = other.file_;
     other.file_ = nullptr;
@@ -220,9 +223,9 @@ class buffered_file {
   FMT_API void close();
 
   // Returns the pointer to a FILE object representing this file.
-  FILE* get() const noexcept { return file_; }
+  auto get() const noexcept -> FILE* { return file_; }
 
-  FMT_API int descriptor() const;
+  FMT_API auto descriptor() const -> int;
 
   void vprint(string_view format_str, format_args args) {
     fmt::vprint(file_, format_str, args);
@@ -272,7 +275,7 @@ class FMT_API file {
   file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }
 
   // Move assignment is not noexcept because close may throw.
-  file& operator=(file&& other) {
+  auto operator=(file&& other) -> file& {
     close();
     fd_ = other.fd_;
     other.fd_ = -1;
@@ -283,24 +286,24 @@ class FMT_API file {
   ~file() noexcept;
 
   // Returns the file descriptor.
-  int descriptor() const noexcept { return fd_; }
+  auto descriptor() const noexcept -> int { return fd_; }
 
   // Closes the file.
   void close();
 
   // Returns the file size. The size has signed type for consistency with
   // stat::st_size.
-  long long size() const;
+  auto size() const -> long long;
 
   // Attempts to read count bytes from the file into the specified buffer.
-  size_t read(void* buffer, size_t count);
+  auto read(void* buffer, size_t count) -> size_t;
 
   // Attempts to write count bytes from the specified buffer to the file.
-  size_t write(const void* buffer, size_t count);
+  auto write(const void* buffer, size_t count) -> size_t;
 
   // Duplicates a file descriptor with the dup function and returns
   // the duplicate as a file object.
-  static file dup(int fd);
+  static auto dup(int fd) -> file;
 
   // Makes fd be the copy of this file descriptor, closing fd first if
   // necessary.
@@ -312,11 +315,12 @@ class FMT_API file {
 
   // Creates a pipe setting up read_end and write_end file objects for reading
   // and writing respectively.
+  // DEPRECATED! Taking files as out parameters is deprecated.
   static void pipe(file& read_end, file& write_end);
 
   // Creates a buffered_file object associated with this file and detaches
   // this file object from the file.
-  buffered_file fdopen(const char* mode);
+  auto fdopen(const char* mode) -> buffered_file;
 
 #  if defined(_WIN32) && !defined(__MINGW32__)
   // Opens a file and constructs a file object representing this file by
@@ -326,14 +330,14 @@ class FMT_API file {
 };
 
 // Returns the memory page size.
-long getpagesize();
+auto getpagesize() -> long;
 
 namespace detail {
 
 struct buffer_size {
   buffer_size() = default;
   size_t value = 0;
-  buffer_size operator=(size_t val) const {
+  auto operator=(size_t val) const -> buffer_size {
     auto bs = buffer_size();
     bs.value = val;
     return bs;
@@ -410,7 +414,7 @@ class FMT_API ostream {
   void flush() { buffer_.flush(); }
 
   template <typename... T>
-  friend ostream output_file(cstring_view path, T... params);
+  friend auto output_file(cstring_view path, T... params) -> ostream;
 
   void close() { buffer_.close(); }
 
@@ -419,7 +423,7 @@ class FMT_API ostream {
     output to the file.
    */
   template <typename... T> void print(format_string<T...> fmt, T&&... args) {
-    vformat_to(detail::buffer_appender<char>(buffer_), fmt,
+    vformat_to(std::back_inserter(buffer_), fmt,
                fmt::make_format_args(args...));
   }
 };
@@ -440,7 +444,7 @@ class FMT_API ostream {
   \endrst
  */
 template <typename... T>
-inline ostream output_file(cstring_view path, T... params) {
+inline auto output_file(cstring_view path, T... params) -> ostream {
   return {path, detail::ostream_params(params...)};
 }
 #endif  // FMT_USE_FCNTL

wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/ostream.h

@@ -10,19 +10,50 @@
 
 #include <fstream>  // std::filebuf
 
-#if defined(_WIN32) && defined(__GLIBCXX__)
-#  include <ext/stdio_filebuf.h>
-#  include <ext/stdio_sync_filebuf.h>
-#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
-#  include <__std_stream>
+#ifdef _WIN32
+#  ifdef __GLIBCXX__
+#    include <ext/stdio_filebuf.h>
+#    include <ext/stdio_sync_filebuf.h>
+#  endif
+#  include <io.h>
 #endif
 
 #include "format.h"
 
 FMT_BEGIN_NAMESPACE
-
 namespace detail {
 
+template <typename Streambuf> class formatbuf : public Streambuf {
+ private:
+  using char_type = typename Streambuf::char_type;
+  using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0));
+  using int_type = typename Streambuf::int_type;
+  using traits_type = typename Streambuf::traits_type;
+
+  buffer<char_type>& buffer_;
+
+ public:
+  explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {}
+
+ protected:
+  // The put area is always empty. This makes the implementation simpler and has
+  // the advantage that the streambuf and the buffer are always in sync and
+  // sputc never writes into uninitialized memory. A disadvantage is that each
+  // call to sputc always results in a (virtual) call to overflow. There is no
+  // disadvantage here for sputn since this always results in a call to xsputn.
+
+  auto overflow(int_type ch) -> int_type override {
+    if (!traits_type::eq_int_type(ch, traits_type::eof()))
+      buffer_.push_back(static_cast<char_type>(ch));
+    return ch;
+  }
+
+  auto xsputn(const char_type* s, streamsize count) -> streamsize override {
+    buffer_.append(s, s + count);
+    return count;
+  }
+};
+
 // Generate a unique explicit instantion in every translation unit using a tag
 // type in an anonymous namespace.
 namespace {
@@ -37,36 +68,40 @@ class file_access {
 template class file_access<file_access_tag, std::filebuf,
                            &std::filebuf::_Myfile>;
 auto get_file(std::filebuf&) -> FILE*;
-#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
-template class file_access<file_access_tag, std::__stdoutbuf<char>,
-                           &std::__stdoutbuf<char>::__file_>;
-auto get_file(std::__stdoutbuf<char>&) -> FILE*;
 #endif
 
-inline bool write_ostream_unicode(std::ostream& os, fmt::string_view data) {
+inline auto write_ostream_unicode(std::ostream& os, fmt::string_view data)
+    -> bool {
+  FILE* f = nullptr;
 #if FMT_MSC_VERSION
   if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
-    if (FILE* f = get_file(*buf)) return write_console(f, data);
-#elif defined(_WIN32) && defined(__GLIBCXX__)
-  auto* rdbuf = os.rdbuf();
-  FILE* c_file;
-  if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
-    c_file = sfbuf->file();
-  else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
-    c_file = fbuf->file();
+    f = get_file(*buf);
+  else
+    return false;
+#elif defined(_WIN32) && defined(__GLIBCXX__)
+  auto* rdbuf = os.rdbuf();
+  if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
+    f = sfbuf->file();
+  else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
+    f = fbuf->file();
   else
     return false;
-  if (c_file) return write_console(c_file, data);
-#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
-  if (auto* buf = dynamic_cast<std::__stdoutbuf<char>*>(os.rdbuf()))
-    if (FILE* f = get_file(*buf)) return write_console(f, data);
 #else
-  ignore_unused(os, data);
+  ignore_unused(os, data, f);
+#endif
+#ifdef _WIN32
+  if (f) {
+    int fd = _fileno(f);
+    if (_isatty(fd)) {
+      os.flush();
+      return write_console(fd, data);
+    }
+  }
 #endif
   return false;
 }
-inline bool write_ostream_unicode(std::wostream&,
-                                  fmt::basic_string_view<wchar_t>) {
+inline auto write_ostream_unicode(std::wostream&,
+                                  fmt::basic_string_view<wchar_t>) -> bool {
   return false;
 }
 
@@ -87,18 +122,19 @@ void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
 }
 
 template <typename Char, typename T>
-void format_value(buffer<Char>& buf, const T& value,
-                  locale_ref loc = locale_ref()) {
+void format_value(buffer<Char>& buf, const T& value) {
   auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
   auto&& output = std::basic_ostream<Char>(&format_buf);
 #if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
-  if (loc) output.imbue(loc.get<std::locale>());
+  output.imbue(std::locale::classic());  // The default is always unlocalized.
 #endif
   output << value;
   output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
 }
 
-template <typename T> struct streamed_view { const T& value; };
+template <typename T> struct streamed_view {
+  const T& value;
+};
 
 }  // namespace detail
 
@@ -111,7 +147,7 @@ struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
   auto format(const T& value, basic_format_context<OutputIt, Char>& ctx) const
       -> OutputIt {
     auto buffer = basic_memory_buffer<Char>();
-    detail::format_value(buffer, value, ctx.locale());
+    detail::format_value(buffer, value);
     return formatter<basic_string_view<Char>, Char>::format(
         {buffer.data(), buffer.size()}, ctx);
   }
@@ -140,7 +176,7 @@ struct formatter<detail::streamed_view<T>, Char>
   \endrst
  */
 template <typename T>
-auto streamed(const T& value) -> detail::streamed_view<T> {
+constexpr auto streamed(const T& value) -> detail::streamed_view<T> {
   return {value};
 }
 

wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/printf.h

@@ -16,13 +16,19 @@
 FMT_BEGIN_NAMESPACE
 FMT_BEGIN_EXPORT
 
-template <typename T> struct printf_formatter { printf_formatter() = delete; };
+template <typename T> struct printf_formatter {
+  printf_formatter() = delete;
+};
 
 template <typename Char> class basic_printf_context {
  private:
   detail::buffer_appender<Char> out_;
   basic_format_args<basic_printf_context> args_;
 
+  static_assert(std::is_same<Char, char>::value ||
+                    std::is_same<Char, wchar_t>::value,
+                "Unsupported code unit type.");
+
  public:
   using char_type = Char;
   using parse_context_type = basic_format_parse_context<Char>;
@@ -102,7 +108,9 @@ struct is_zero_int {
 
 template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};
 
-template <> struct make_unsigned_or_bool<bool> { using type = bool; };
+template <> struct make_unsigned_or_bool<bool> {
+  using type = bool;
+};
 
 template <typename T, typename Context> class arg_converter {
  private:

wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/ranges.h

@@ -1,13 +1,9 @@
-// Formatting library for C++ - experimental range support
+// Formatting library for C++ - range and tuple support
 //
-// Copyright (c) 2012 - present, Victor Zverovich
+// Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors
 // All rights reserved.
 //
 // For the license information refer to format.h.
-//
-// Copyright (c) 2018 - present, Remotion (Igor Schulz)
-// All Rights Reserved
-// {fmt} support for ranges, containers and types tuple interface.
 
 #ifndef FMT_RANGES_H_
 #define FMT_RANGES_H_
@@ -187,7 +183,7 @@ template <size_t N> using make_index_sequence = std::make_index_sequence<N>;
 template <typename T, T... N> struct integer_sequence {
   using value_type = T;
 
-  static FMT_CONSTEXPR size_t size() { return sizeof...(N); }
+  static FMT_CONSTEXPR auto size() -> size_t { return sizeof...(N); }
 };
 
 template <size_t... N> using index_sequence = integer_sequence<size_t, N...>;
@@ -211,15 +207,15 @@ class is_tuple_formattable_ {
 };
 template <typename T, typename C> class is_tuple_formattable_<T, C, true> {
   template <std::size_t... Is>
-  static std::true_type check2(index_sequence<Is...>,
-                               integer_sequence<bool, (Is == Is)...>);
-  static std::false_type check2(...);
+  static auto check2(index_sequence<Is...>,
+                     integer_sequence<bool, (Is == Is)...>) -> std::true_type;
+  static auto check2(...) -> std::false_type;
   template <std::size_t... Is>
-  static decltype(check2(
+  static auto check(index_sequence<Is...>) -> decltype(check2(
       index_sequence<Is...>{},
-      integer_sequence<
-          bool, (is_formattable<typename std::tuple_element<Is, T>::type,
-                                C>::value)...>{})) check(index_sequence<Is...>);
+      integer_sequence<bool,
+                       (is_formattable<typename std::tuple_element<Is, T>::type,
+                                       C>::value)...>{}));
 
  public:
   static constexpr const bool value =
@@ -421,6 +417,12 @@ struct is_formattable_delayed
 #endif
 }  // namespace detail
 
+template <typename...> struct conjunction : std::true_type {};
+template <typename P> struct conjunction<P> : P {};
+template <typename P1, typename... Pn>
+struct conjunction<P1, Pn...>
+    : conditional_t<bool(P1::value), conjunction<Pn...>, P1> {};
+
 template <typename T, typename Char, typename Enable = void>
 struct range_formatter;
 
@@ -486,7 +488,8 @@ struct range_formatter<
     for (; it != end; ++it) {
       if (i > 0) out = detail::copy_str<Char>(separator_, out);
       ctx.advance_to(out);
-      out = underlying_.format(mapper.map(*it), ctx);
+      auto&& item = *it;
+      out = underlying_.format(mapper.map(item), ctx);
       ++i;
     }
     out = detail::copy_str<Char>(closing_bracket_, out);

wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/std.h

@@ -38,6 +38,10 @@
 #  endif
 #endif
 
+#if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<source_location>)
+#  include <source_location>
+#endif
+
 // GCC 4 does not support FMT_HAS_INCLUDE.
 #if FMT_HAS_INCLUDE(<cxxabi.h>) || defined(__GLIBCXX__)
 #  include <cxxabi.h>
@@ -59,43 +63,53 @@
 #  endif
 #endif
 
-#ifdef __cpp_lib_filesystem
+// For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined.
+#ifndef FMT_CPP_LIB_FILESYSTEM
+#  ifdef __cpp_lib_filesystem
+#    define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem
+#  else
+#    define FMT_CPP_LIB_FILESYSTEM 0
+#  endif
+#endif
+
+#ifndef FMT_CPP_LIB_VARIANT
+#  ifdef __cpp_lib_variant
+#    define FMT_CPP_LIB_VARIANT __cpp_lib_variant
+#  else
+#    define FMT_CPP_LIB_VARIANT 0
+#  endif
+#endif
+
+#if FMT_CPP_LIB_FILESYSTEM
 FMT_BEGIN_NAMESPACE
 
 namespace detail {
 
-template <typename Char> auto get_path_string(const std::filesystem::path& p) {
-  return p.string<Char>();
+template <typename Char, typename PathChar>
+auto get_path_string(const std::filesystem::path& p,
+                     const std::basic_string<PathChar>& native) {
+  if constexpr (std::is_same_v<Char, char> && std::is_same_v<PathChar, wchar_t>)
+    return to_utf8<wchar_t>(native, to_utf8_error_policy::replace);
+  else
+    return p.string<Char>();
 }
 
-template <typename Char>
+template <typename Char, typename PathChar>
 void write_escaped_path(basic_memory_buffer<Char>& quoted,
-                        const std::filesystem::path& p) {
-  write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
-}
-
-#  ifdef _WIN32
-template <>
-inline auto get_path_string<char>(const std::filesystem::path& p) {
-  return to_utf8<wchar_t>(p.native(), to_utf8_error_policy::replace);
-}
-
-template <>
-inline void write_escaped_path<char>(memory_buffer& quoted,
-                                     const std::filesystem::path& p) {
-  auto buf = basic_memory_buffer<wchar_t>();
-  write_escaped_string<wchar_t>(std::back_inserter(buf), p.native());
-  bool valid = to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()});
-  FMT_ASSERT(valid, "invalid utf16");
-}
-#  endif  // _WIN32
-
-template <>
-inline void write_escaped_path<std::filesystem::path::value_type>(
-    basic_memory_buffer<std::filesystem::path::value_type>& quoted,
-    const std::filesystem::path& p) {
-  write_escaped_string<std::filesystem::path::value_type>(
-      std::back_inserter(quoted), p.native());
+                        const std::filesystem::path& p,
+                        const std::basic_string<PathChar>& native) {
+  if constexpr (std::is_same_v<Char, char> &&
+                std::is_same_v<PathChar, wchar_t>) {
+    auto buf = basic_memory_buffer<wchar_t>();
+    write_escaped_string<wchar_t>(std::back_inserter(buf), native);
+    bool valid = to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()});
+    FMT_ASSERT(valid, "invalid utf16");
+  } else if constexpr (std::is_same_v<Char, PathChar>) {
+    write_escaped_string<std::filesystem::path::value_type>(
+        std::back_inserter(quoted), native);
+  } else {
+    write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
+  }
 }
 
 }  // namespace detail
@@ -106,6 +120,7 @@ template <typename Char> struct formatter<std::filesystem::path, Char> {
   format_specs<Char> specs_;
   detail::arg_ref<Char> width_ref_;
   bool debug_ = false;
+  char path_type_ = 0;
 
  public:
   FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }
@@ -122,29 +137,62 @@ template <typename Char> struct formatter<std::filesystem::path, Char> {
       debug_ = true;
       ++it;
     }
+    if (it != end && (*it == 'g')) path_type_ = *it++;
     return it;
   }
 
   template <typename FormatContext>
   auto format(const std::filesystem::path& p, FormatContext& ctx) const {
     auto specs = specs_;
+#  ifdef _WIN32
+    auto path_string = !path_type_ ? p.native() : p.generic_wstring();
+#  else
+    auto path_string = !path_type_ ? p.native() : p.generic_string();
+#  endif
+
     detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
                                                        ctx);
     if (!debug_) {
-      auto s = detail::get_path_string<Char>(p);
+      auto s = detail::get_path_string<Char>(p, path_string);
       return detail::write(ctx.out(), basic_string_view<Char>(s), specs);
     }
     auto quoted = basic_memory_buffer<Char>();
-    detail::write_escaped_path(quoted, p);
+    detail::write_escaped_path(quoted, p, path_string);
     return detail::write(ctx.out(),
                          basic_string_view<Char>(quoted.data(), quoted.size()),
                          specs);
   }
 };
 FMT_END_NAMESPACE
-#endif
+#endif  // FMT_CPP_LIB_FILESYSTEM
 
 FMT_BEGIN_NAMESPACE
+FMT_EXPORT
+template <std::size_t N, typename Char>
+struct formatter<std::bitset<N>, Char> : nested_formatter<string_view> {
+ private:
+  // Functor because C++11 doesn't support generic lambdas.
+  struct writer {
+    const std::bitset<N>& bs;
+
+    template <typename OutputIt>
+    FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt {
+      for (auto pos = N; pos > 0; --pos) {
+        out = detail::write<Char>(out, bs[pos - 1] ? Char('1') : Char('0'));
+      }
+
+      return out;
+    }
+  };
+
+ public:
+  template <typename FormatContext>
+  auto format(const std::bitset<N>& bs, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    return write_padded(ctx, writer{bs});
+  }
+};
+
 FMT_EXPORT
 template <typename Char>
 struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
@@ -180,7 +228,7 @@ struct formatter<std::optional<T>, Char,
   }
 
   template <typename FormatContext>
-  auto format(std::optional<T> const& opt, FormatContext& ctx) const
+  auto format(const std::optional<T>& opt, FormatContext& ctx) const
       -> decltype(ctx.out()) {
     if (!opt) return detail::write<Char>(ctx.out(), none);
 
@@ -194,7 +242,32 @@ struct formatter<std::optional<T>, Char,
 FMT_END_NAMESPACE
 #endif  // __cpp_lib_optional
 
-#ifdef __cpp_lib_variant
+#ifdef __cpp_lib_source_location
+FMT_BEGIN_NAMESPACE
+FMT_EXPORT
+template <> struct formatter<std::source_location> {
+  template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(const std::source_location& loc, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    out = detail::write(out, loc.file_name());
+    out = detail::write(out, ':');
+    out = detail::write<char>(out, loc.line());
+    out = detail::write(out, ':');
+    out = detail::write<char>(out, loc.column());
+    out = detail::write(out, ": ");
+    out = detail::write(out, loc.function_name());
+    return out;
+  }
+};
+FMT_END_NAMESPACE
+#endif
+
+#if FMT_CPP_LIB_VARIANT
 FMT_BEGIN_NAMESPACE
 namespace detail {
 
@@ -285,7 +358,7 @@ struct formatter<
   }
 };
 FMT_END_NAMESPACE
-#endif  // __cpp_lib_variant
+#endif  // FMT_CPP_LIB_VARIANT
 
 FMT_BEGIN_NAMESPACE
 FMT_EXPORT
@@ -309,7 +382,7 @@ template <typename Char> struct formatter<std::error_code, Char> {
 FMT_EXPORT
 template <typename T, typename Char>
 struct formatter<
-    T, Char,
+    T, Char,  // DEPRECATED! Mixing code unit types.
     typename std::enable_if<std::is_base_of<std::exception, T>::value>::type> {
  private:
   bool with_typename_ = false;
@@ -340,7 +413,7 @@ struct formatter<
 #  ifdef FMT_HAS_ABI_CXA_DEMANGLE
     int status = 0;
     std::size_t size = 0;
-    std::unique_ptr<char, decltype(&std::free)> demangled_name_ptr(
+    std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
         abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
 
     string_view demangled_name_view;
@@ -451,15 +524,14 @@ struct formatter<std::atomic<T>, Char,
 #ifdef __cpp_lib_atomic_flag_test
 FMT_EXPORT
 template <typename Char>
-struct formatter<std::atomic_flag, Char>
-    : formatter<bool, Char> {
+struct formatter<std::atomic_flag, Char> : formatter<bool, Char> {
   template <typename FormatContext>
   auto format(const std::atomic_flag& v, FormatContext& ctx) const
       -> decltype(ctx.out()) {
     return formatter<bool, Char>::format(v.test(), ctx);
   }
 };
-#endif // __cpp_lib_atomic_flag_test
+#endif  // __cpp_lib_atomic_flag_test
 
 FMT_END_NAMESPACE
 #endif  // FMT_STD_H_

wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/xchar.h

@@ -63,14 +63,15 @@ template <> struct is_char<char16_t> : std::true_type {};
 template <> struct is_char<char32_t> : std::true_type {};
 
 template <typename... T>
-constexpr format_arg_store<wformat_context, T...> make_wformat_args(
-    const T&... args) {
+constexpr auto make_wformat_args(const T&... args)
+    -> format_arg_store<wformat_context, T...> {
   return {args...};
 }
 
 inline namespace literals {
 #if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_ARGS
-constexpr detail::udl_arg<wchar_t> operator"" _a(const wchar_t* s, size_t) {
+constexpr auto operator""_a(const wchar_t* s, size_t)
+    -> detail::udl_arg<wchar_t> {
   return {s};
 }
 #endif
@@ -172,11 +173,11 @@ inline auto vformat_to(
   return detail::get_iterator(buf, out);
 }
 
-template <
-    typename OutputIt, typename Locale, typename S, typename... T,
-    typename Char = char_t<S>,
-    bool enable = detail::is_output_iterator<OutputIt, Char>::value&&
-        detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value>
+template <typename OutputIt, typename Locale, typename S, typename... T,
+          typename Char = char_t<S>,
+          bool enable = detail::is_output_iterator<OutputIt, Char>::value &&
+                        detail::is_locale<Locale>::value &&
+                        detail::is_exotic_char<Char>::value>
 inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
                       T&&... args) ->
     typename std::enable_if<enable, OutputIt>::type {
@@ -220,7 +221,8 @@ inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) {
   auto buf = wmemory_buffer();
   detail::vformat_to(buf, fmt, args);
   buf.push_back(L'\0');
-  std::fputws(buf.data(), f);
+  if (std::fputws(buf.data(), f) == -1)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }
 
 inline void vprint(wstring_view fmt, wformat_args args) {

wpiutil/src/main/native/thirdparty/fmtlib/src/os.cpp

@@ -18,8 +18,8 @@
 #  include <sys/stat.h>
 #  include <sys/types.h>
 
-#  ifdef _WRS_KERNEL   // VxWorks7 kernel
-#    include <ioLib.h> // getpagesize
+#  ifdef _WRS_KERNEL    // VxWorks7 kernel
+#    include <ioLib.h>  // getpagesize
 #  endif
 
 #  ifndef _WIN32
@@ -182,10 +182,14 @@ void buffered_file::close() {
 }
 
 int buffered_file::descriptor() const {
-#ifdef fileno  // fileno is a macro on OpenBSD so we cannot use FMT_POSIX_CALL.
-  int fd = fileno(file_);
-#else
+#if !defined(fileno)
   int fd = FMT_POSIX_CALL(fileno(file_));
+#elif defined(FMT_HAS_SYSTEM)
+  // fileno is a macro on OpenBSD so we cannot use FMT_POSIX_CALL.
+#  define FMT_DISABLE_MACRO
+  int fd = FMT_SYSTEM(fileno FMT_DISABLE_MACRO(file_));
+#else
+  int fd = fileno(file_);
 #endif
   if (fd == -1)
     FMT_THROW(system_error(errno, FMT_STRING("cannot get file descriptor")));
@@ -258,7 +262,9 @@ long long file::size() const {
 std::size_t file::read(void* buffer, std::size_t count) {
   rwresult result = 0;
   FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count))));
-  return count;
+  if (result < 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot read from file")));
+  return detail::to_unsigned(result);
 }
 
 std::size_t file::write(const void* buffer, std::size_t count) {

wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/ErrorHandling.cpp

@@ -15,7 +15,7 @@
 #include "wpi/SmallVector.h"
 #include "wpi/Errc.h"
 #include "wpi/WindowsError.h"
-#include "fmt/format.h"
+#include "wpi/print.h"
 #include <cassert>
 #include <cstdlib>
 #include <mutex>
@@ -86,7 +86,7 @@ void wpi::report_fatal_error(std::string_view Reason, bool GenCrashDiag) {
   if (handler) {
     handler(handlerData, std::string{Reason}.c_str(), GenCrashDiag);
   } else {
-    fmt::print(stderr, "LLVM ERROR: {}\n", Reason);
+    wpi::print(stderr, "LLVM ERROR: {}\n", Reason);
   }
 
   exit(1);
@@ -159,11 +159,11 @@ void wpi::wpi_unreachable_internal(const char *msg, const char *file,
   // wpi_unreachable is intended to be used to indicate "impossible"
   // situations, and not legitimate runtime errors.
   if (msg)
-    fmt::print(stderr, "{}\n", msg);
+    wpi::print(stderr, "{}\n", msg);
   std::fputs("UNREACHABLE executed", stderr);
   if (file)
-    fmt::print(stderr, " at {}:{}", file, line);
-  fmt::print(stderr, "!\n");
+    wpi::print(stderr, " at {}:{}", file, line);
+  wpi::print(stderr, "!\n");
   abort();
 #ifdef LLVM_BUILTIN_UNREACHABLE
   // Windows systems and possibly others don't declare abort() to be noreturn,

wpiutil/src/test/native/cpp/spinlock_bench.cpp

@@ -8,10 +8,10 @@
 #include <mutex>
 #include <thread>
 
-#include <fmt/core.h>
 #include <gtest/gtest.h>
 
 #include "wpi/mutex.h"
+#include "wpi/print.h"
 
 static std::mutex std_mutex;
 static std::recursive_mutex std_recursive_mutex;
@@ -52,7 +52,7 @@ TEST(SpinlockTest, Benchmark) {
       ++value;
     }
     auto stop = high_resolution_clock::now();
-    fmt::print("std::mutex sizeof: {} time: {} value: {}\n", sizeof(std_mutex),
+    wpi::print("std::mutex sizeof: {} time: {} value: {}\n", sizeof(std_mutex),
                duration_cast<microseconds>(stop - start).count(), value);
   });
   thrb.join();
@@ -66,7 +66,7 @@ TEST(SpinlockTest, Benchmark) {
       ++value;
     }
     auto stop = high_resolution_clock::now();
-    fmt::print("std::recursive_mutex sizeof: {} time: {} value: {}\n",
+    wpi::print("std::recursive_mutex sizeof: {} time: {} value: {}\n",
                sizeof(std_recursive_mutex),
                duration_cast<microseconds>(stop - start).count(), value);
   });
@@ -81,7 +81,7 @@ TEST(SpinlockTest, Benchmark) {
       ++value;
     }
     auto stop = high_resolution_clock::now();
-    fmt::print("wpi::mutex sizeof: {} time: {} value: {}\n", sizeof(wpi_mutex),
+    wpi::print("wpi::mutex sizeof: {} time: {} value: {}\n", sizeof(wpi_mutex),
                duration_cast<microseconds>(stop - start).count(), value);
   });
   thr2.join();
@@ -95,7 +95,7 @@ TEST(SpinlockTest, Benchmark) {
       ++value;
     }
     auto stop = high_resolution_clock::now();
-    fmt::print("wpi::recursive_mutex sizeof: {} time: {} value: {}\n",
+    wpi::print("wpi::recursive_mutex sizeof: {} time: {} value: {}\n",
                sizeof(wpi_recursive_mutex),
                duration_cast<microseconds>(stop - start).count(), value);
   });
@@ -110,7 +110,7 @@ TEST(SpinlockTest, Benchmark) {
       ++value;
     }
     auto stop = high_resolution_clock::now();
-    fmt::print("spinlock sizeof: {} time: {} value: {}\n", sizeof(spinlock),
+    wpi::print("spinlock sizeof: {} time: {} value: {}\n", sizeof(spinlock),
                duration_cast<microseconds>(stop - start).count(), value);
   });
   thr3.join();
@@ -124,7 +124,7 @@ TEST(SpinlockTest, Benchmark) {
       ++value;
     }
     auto stop = high_resolution_clock::now();
-    fmt::print("recursive_spinlock1 sizeof: {} time: {} value: {}\n",
+    wpi::print("recursive_spinlock1 sizeof: {} time: {} value: {}\n",
                sizeof(recursive_spinlock1),
                duration_cast<microseconds>(stop - start).count(), value);
   });
@@ -139,7 +139,7 @@ TEST(SpinlockTest, Benchmark) {
       ++value;
     }
     auto stop = high_resolution_clock::now();
-    fmt::print("recursive_spinlock2 sizeof: {} time: {} value: {}\n",
+    wpi::print("recursive_spinlock2 sizeof: {} time: {} value: {}\n",
                sizeof(recursive_spinlock2),
                duration_cast<microseconds>(stop - start).count(), value);
   });
@@ -154,7 +154,7 @@ TEST(SpinlockTest, Benchmark) {
       ++value;
     }
     auto stop = high_resolution_clock::now();
-    fmt::print("recursive_spinlock sizeof: {} time: {} value: {}\n",
+    wpi::print("recursive_spinlock sizeof: {} time: {} value: {}\n",
                sizeof(recursive_spinlock),
                duration_cast<microseconds>(stop - start).count(), value);
   });