Use std::format in multiple places

Author: rafalh

common/include/common/config/RegKey.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <utility>
+#include <cstdint>
 #include <windows.h>
 #include <common/error/Win32Error.h>
 

common/include/common/error/Exception.h

@@ -1,10 +1,8 @@
 #pragma once
 
-#include <cstdarg>
-#include <cstdio>
 #include <exception>
 #include <string>
-#include <memory>
+#include <format>
 
 #define THROW_EXCEPTION(...) throw Exception({__FILE__, __LINE__}, __VA_ARGS__)
 
@@ -17,24 +15,11 @@ class Exception : public std::exception
         int line;
     };
 
-    Exception(SourceLocation loc, const char* format, ...)
+    template<typename... Args>
+    Exception(SourceLocation loc, std::format_string<Args...> fmt, Args&&... args)
     {
-        va_list args;
-        va_start(args, format);
-        int size = 1;
-        size += std::vsnprintf(nullptr, 0, format, args);
-        size += std::snprintf(nullptr, 0, " in %s:%u", loc.file, loc.line);
-        va_end(args);
-
-        std::unique_ptr<char[]> buf(new char[size]);
-
-        va_start(args, format);
-        int pos = 0;
-        pos += std::vsnprintf(buf.get() + pos, size - pos, format, args);
-        std::snprintf(buf.get() + pos, size - pos, " in %s:%u", loc.file, loc.line);
-        va_end(args);
-
-        m_what = buf.get();
+        m_what = std::format(fmt, std::forward<Args>(args)...);
+        std::format_to(std::back_inserter(m_what), " in {}:{}", loc.file, loc.line);
     }
 
     [[nodiscard]] const char* what() const noexcept override

common/include/common/utils/string-utils.h

@@ -164,22 +164,6 @@ struct StringMatcher
     }
 };
 
-PRINTF_FMT_ATTRIBUTE(1, 2)
-inline std::string string_format(const char* format, ...)
-{
-    std::va_list args;
-    va_start(args, format);
-    int size = vsnprintf(nullptr, 0, format, args) + 1; // Extra space for '\0'
-    va_end(args);
-    std::string str;
-    str.resize(size);
-    va_start(args, format);
-    vsnprintf(str.data(), size, format, args);
-    va_end(args);
-    str.resize(size - 1); // We don't want the '\0' inside
-    return str;
-}
-
 inline std::string_view get_filename_without_ext(std::string_view filename)
 {
     auto dot_pos = filename.rfind('.');

common/src/HttpRequest.cpp

@@ -2,7 +2,7 @@
 #include <common/error/Win32Error.h>
 #include <string>
 #include <string_view>
-#include <sstream>
+#include <format>
 #include <cassert>
 #include <cctype>
 
@@ -19,11 +19,11 @@ static ParsedUrl parse_http_url(std::string_view url)
     std::string_view http = "http://";
     std::string_view https = "https://";
     size_t host_pos = 0;
-    if (url.substr(0, https.size()) == https) {
+    if (url.starts_with(https)) {
         result.ssl = true;
         host_pos = https.size();
     }
-    else if (url.substr(0, http.size()) == http) {
+    else if (url.starts_with(http)) {
         result.ssl = false;
         host_pos = http.size();
     }
@@ -95,9 +95,7 @@ HttpRequest::HttpRequest(std::string_view url, const char* method, HttpSession&
 
 void HttpRequest::add_header(std::string_view name, std::string_view value)
 {
-    std::stringstream sstream;
-    sstream << name << ": " << value << "\r\n";
-    auto str = sstream.str();
+    auto str = std::format("{}: {}", name, value);
     add_raw_headers(str);
 }
 
@@ -124,7 +122,7 @@ void HttpRequest::write(const void* data, size_t len)
         if (!InternetWriteFile(m_req, data, len, &written))
             THROW_WIN32_ERROR();
         if (!written)
-            THROW_EXCEPTION("Unable to write %lu request body bytes", len);
+            THROW_EXCEPTION("Unable to write {} request body bytes", len);
         data = static_cast<const std::byte*>(data) + written;
         len -= written;
     }
@@ -150,7 +148,7 @@ void HttpRequest::send(std::string_view body)
     }
 
     if (status_code != 200) {
-        throw std::runtime_error(std::string("Invalid HTTP status code: ") + std::to_string(status_code));
+        throw std::runtime_error(std::format("Invalid HTTP status code: {}", status_code));
     }
 }
 
@@ -200,13 +198,11 @@ static bool is_uri_reserved_char(char c)
 
 std::string encode_uri_component(std::string_view value)
 {
-    char buf[8];
     std::string result;
     result.reserve(value.size());
     for (char c : value) {
         if (is_uri_reserved_char(c)) {
-            sprintf(buf, "%%%02X", static_cast<unsigned char>(c));
-            result += buf;
+            std::format_to(std::back_inserter(result), "%{:02X}", static_cast<unsigned char>(c));
         } else {
             result += c;
         }

common/src/utils/os-utils.cpp

@@ -1,10 +1,9 @@
 #include <common/utils/os-utils.h>
-#include <common/utils/string-utils.h>
 #include <xlog/xlog.h>
-#include <iomanip>
 #include <common/error/Exception.h>
 #include <common/error/Win32Error.h>
 #include <cstring>
+#include <format>
 
 #ifdef __GNUC__
 #ifndef __cpuid
@@ -21,7 +20,7 @@ std::string get_os_version()
     if (!GetVersionEx(&ver_info))
         THROW_WIN32_ERROR("GetVersionEx failed");
 
-    return string_format("%lu.%lu.%lu", ver_info.dwMajorVersion, ver_info.dwMinorVersion, ver_info.dwBuildNumber);
+    return std::format("{}.{}.{}", ver_info.dwMajorVersion, ver_info.dwMinorVersion, ver_info.dwBuildNumber);
 }
 
 std::string get_real_os_version()
@@ -50,7 +49,7 @@ std::string get_real_os_version()
         THROW_WIN32_ERROR("VerQueryValueA returned unknown block");
     auto* file_info = static_cast<VS_FIXEDFILEINFO*>(block);
 
-    return string_format("%d.%d.%d",
+    return std::format("{}.{}.{}",
                         HIWORD(file_info->dwProductVersionMS),
                         LOWORD(file_info->dwProductVersionMS),
                         HIWORD(file_info->dwProductVersionLS));
@@ -119,15 +118,12 @@ const char* get_process_elevation_type()
 std::string get_cpu_id()
 {
     int cpu_info[4] = {0};
-    std::stringstream ss;
 #ifndef __GNUC__
     __cpuid(cpu_info, 1);
 #else
     __cpuid(1, cpu_info[0], cpu_info[1], cpu_info[2], cpu_info[3]);
 #endif
-    ss << std::hex << std::uppercase << std::setfill('0') << std::setw(8) << cpu_info[0] << ' ' << cpu_info[1] << ' '
-       << cpu_info[2] << ' ' << cpu_info[3];
-    return ss.str();
+    return std::format("{:08X} {:08X} {:08X} {:08X}", cpu_info[0], cpu_info[1], cpu_info[2], cpu_info[3]);
 }
 
 std::string get_cpu_brand()

crash_handler/MiniDumpHelper.cpp

@@ -1,4 +1,5 @@
 #include "MiniDumpHelper.h"
+#include <format>
 
 #define CRASHHANDLER_ERR(msg) MessageBox(nullptr, TEXT(msg), 0, MB_ICONERROR | MB_OK | MB_SETFOREGROUND | MB_TASKMODAL)
 
@@ -75,9 +76,8 @@ bool MiniDumpHelper::write_dump(const char* path, PEXCEPTION_POINTERS exception_
                         nullptr);
 
     if (INVALID_HANDLE_VALUE == file) {
-        char buf[256];
-        sprintf(buf, "Error %lu! CreateFile failed when writing a Minidump.", GetLastError());
-        CRASHHANDLER_ERR(buf);
+        std::string s = std::format("Error {}! CreateFile failed when writing a Minidump.", GetLastError());
+        CRASHHANDLER_ERR(s.c_str());
         return false;
     }
 
@@ -119,9 +119,8 @@ bool MiniDumpHelper::write_dump(const char* path, PEXCEPTION_POINTERS exception_
     auto process_id = GetProcessId(process);
     BOOL result = m_MiniDumpWriteDump(process, process_id, file, dump_type, &exc_info, nullptr, callback_info_ptr);
     if (!result) {
-        char buf[256];
-        sprintf(buf, "MiniDumpWriteDump %lu %lu %p failed with error %lu", process_id, thread_id, file, GetLastError());
-        CRASHHANDLER_ERR(buf); // ERROR_INVALID_PARAMETER?
+        std::string s = std::format("MiniDumpWriteDump {} {} {} failed with error {}", process_id, thread_id, file, GetLastError());
+        CRASHHANDLER_ERR(s.c_str()); // ERROR_INVALID_PARAMETER?
     }
 
     CloseHandle(file);

crash_handler/TextDumpHelper.h

@@ -1,8 +1,8 @@
 #include <windows.h>
 #include <psapi.h>
 #include <common/error/Win32Error.h>
-#include <ostream>
 #include <fstream>
+#include <format>
 #include <ctime>
 #include <cassert>
 #include <cstring>
@@ -12,19 +12,6 @@
 #include <cstddef>
 #include "ProcessMemoryCache.h"
 
-inline std::string StringFormat(const char* format, ...)
-{
-    va_list args;
-    va_start(args, format);
-    int size = vsnprintf(nullptr, 0, format, args) + 1;// Extra space for '\0'
-    va_end(args);
-    std::unique_ptr<char[]> buf(new char[size]);
-    va_start(args, format);
-    vsnprintf(buf.get(), size, format, args);
-    va_end(args);
-    return std::string(buf.get(), buf.get() + size - 1); // We don't want the '\0' inside
-}
-
 class TextDumpHelper {
 private:
     SYSTEM_INFO m_sys_info;
@@ -70,7 +57,7 @@ class TextDumpHelper {
             }
             if (prefix) {
                 auto addr = exc_rec.ExceptionInformation[1];
-                out << prefix << StringFormat(" location %08X caused an access violation.\n", addr);
+                out << prefix << std::format(" location {:08X} caused an access violation.\n", addr);
             }
         }
         out << std::endl;
@@ -125,20 +112,20 @@ class TextDumpHelper {
     void write_exception_info(std::ostream& out, const EXCEPTION_RECORD& exc_rec)
     {
         out << "Exception Record:\n";
-        out << "  ExceptionCode = " << StringFormat("%08X", exc_rec.ExceptionCode) << "\n";
-        out << "  ExceptionFlags = " << StringFormat("%08X", exc_rec.ExceptionFlags) << "\n";
-        out << "  ExceptionAddress = " << StringFormat("%08X", exc_rec.ExceptionAddress) << "\n";
+        out << "  ExceptionCode = " << std::format("{:08X}", exc_rec.ExceptionCode) << "\n";
+        out << "  ExceptionFlags = " << std::format("{:08X}", exc_rec.ExceptionFlags) << "\n";
+        out << "  ExceptionAddress = " << std::format("{}", exc_rec.ExceptionAddress) << "\n";
         for (unsigned i = 0; i < exc_rec.NumberParameters; ++i)
-            out << "  ExceptionInformation[" << i << "] = " << StringFormat("%08X", exc_rec.ExceptionInformation[i]) << "\n";
+            out << "  ExceptionInformation[" << i << "] = " << std::format("{:08X}", exc_rec.ExceptionInformation[i]) << "\n";
         out << std::endl;
     }
 
     void write_context(std::ostream& out, const CONTEXT& ctx)
     {
         out << "Context:\n";
-        out << StringFormat("EIP=%08X EFLAGS=%08X\n", ctx.Eip, ctx.EFlags);
-        out << StringFormat("EAX=%08X EBX=%08X ECX=%08X EDX=%08X\n", ctx.Eax, ctx.Ebx, ctx.Ecx, ctx.Edx);
-        out << StringFormat("ESP=%08X EBP=%08X ESI=%08X EDI=%08X\n", ctx.Esp, ctx.Ebp, ctx.Esi, ctx.Edi);
+        out << std::format("EIP={:08X} EFLAGS={:08X}\n", ctx.Eip, ctx.EFlags);
+        out << std::format("EAX={:08X} EBX={:08X} ECX={:08X} EDX={:08X}\n", ctx.Eax, ctx.Ebx, ctx.Ecx, ctx.Edx);
+        out << std::format("ESP={:08X} EBP={:08X} ESI={:08X} EDI={:08X}\n", ctx.Esp, ctx.Ebp, ctx.Esi, ctx.Edi);
         out << std::endl;
     }
 
@@ -158,9 +145,9 @@ class TextDumpHelper {
     {
         out << "Memory map:\n";
         for (auto& mbi: m_memory_map) {
-            out << StringFormat("%08X: State %08X Protect %08X Type %08X RegionSize %08X\n",
+            out << std::format("{}: State {:08X} Protect {:08X} Type {:08X} RegionSize {:08X}\n",
                 mbi.BaseAddress, mbi.State, mbi.Protect, mbi.Type, mbi.RegionSize);
-            //out << StringFormat("  AllocBase %x AllocProtect %x\n", mbi.AllocationBase, mbi.AllocationProtect);
+            //out << std::format("  AllocBase {:x} AllocProtect {:x}\n", mbi.AllocationBase, mbi.AllocationProtect);
         }
         out << std::endl;
     }
@@ -357,15 +344,15 @@ class TextDumpHelper {
     {
         constexpr size_t num_cols = 8;
         for (unsigned i = 0; i < num_dwords; i += num_cols) {
-            out << StringFormat("%08X:", base_addr + i * 4);
+            out << std::format("{:08X}:", base_addr + i * 4);
             for (size_t j = 0; j < num_cols && i + j < num_dwords; ++j) {
-                out << StringFormat(" %08X", data[i + j]);
+                out << std::format(" {:08X}", data[i + j]);
             }
             out << "  ";
             for (size_t j = 0; j < num_cols && i + j < num_dwords; ++j) {
                 const char* as_chars = reinterpret_cast<const char*>(&data[i + j]);
                 for (size_t k = 0; k < 4; ++k) {
-                    out << StringFormat("%c", std::isprint(as_chars[k]) ? as_chars[k] : '.');
+                    out << (std::isprint(as_chars[k]) ? as_chars[k] : '.');
                 }
             }
             out << '\n';
@@ -403,21 +390,21 @@ class TextDumpHelper {
     {
         out << "Modules:\n";
         for (auto& mod_info : m_modules) {
-            out << StringFormat("%08X - %08X: %s\n", mod_info.start_addr, mod_info.end_addr, mod_info.path.c_str());
+            out << std::format("{:08X} - {:08X}: {}\n", mod_info.start_addr, mod_info.end_addr, mod_info.path);
         }
         out << std::endl;
     }
 
     std::string format_module_relative_address(uintptr_t addr)
     {
-        std::stringstream ss;
-        ss << StringFormat("%08X", addr);
+        std::string buf;
+        std::format_to(std::back_inserter(buf), "{:08X}", addr);
         for (auto& mod_info : m_modules) {
             if (addr >= mod_info.start_addr && addr < mod_info.end_addr) {
-                ss << StringFormat(" (%s+%X)", mod_info.name.c_str(), addr - mod_info.start_addr);
+                std::format_to(std::back_inserter(buf), " ({}+{:X})", mod_info.name, addr - mod_info.start_addr);
                 break;
             }
         }
-        return ss.str();
+        return buf;
     }
 };

crash_handler/ZipHelper.h

@@ -40,7 +40,7 @@ class ZipHelper
 
         std::ifstream file(path, std::ios_base::in | std::ios_base::binary);
         if (!file)
-            THROW_EXCEPTION("cannot open %s", path);
+            THROW_EXCEPTION("cannot open {}", path);
 
         char buf[4096];
         while (!file.eof()) {

crash_handler/main.cpp

@@ -1,5 +1,6 @@
 #include "CrashReportApp.h"
 #include <common/error/error-utils.h>
+#include <format>
 
 int APIENTRY WinMain(HINSTANCE, HINSTANCE, LPSTR, int) try
 {
@@ -13,17 +14,13 @@ int APIENTRY WinMain(HINSTANCE, HINSTANCE, LPSTR, int) try
 catch (const Win32xx::CException &e)
 {
     // Display the exception and quit
-    std::ostringstream ss;
-    ss << e.GetText() << "\nerror " << e.GetError() << ": " << e.GetErrorString();
-    auto msg = ss.str();
+    std::string msg = std::format("{}\nerror {}: {}", e.GetText(), e.GetError(), e.GetErrorString());
     MessageBox(nullptr, msg.c_str(), nullptr, MB_ICONERROR | MB_OK);
-
     return -1;
 }
 // catch all unhandled std::exception types
 catch (const std::exception& e) {
-    std::string msg = "Fatal error: ";
-    msg += generate_message_for_exception(e);
+    std::string msg = std::format("Fatal error: {}", generate_message_for_exception(e));
     MessageBox(nullptr, msg.c_str(), nullptr, MB_ICONERROR | MB_OK);
     return -1;
 }

editor_patch/main.cpp

@@ -287,14 +287,12 @@ void CMainFrame_InvertSelection(CWnd* this_)
 
 BOOL __fastcall CMainFrame_OnCmdMsg(CWnd* this_, int, UINT nID, int nCode, void* pExtra, void* pHandlerInfo)
 {
-    char buf[256];
     constexpr int CN_COMMAND = 0;
 
     if (nCode == CN_COMMAND) {
         std::function<void()> handler;
         switch (nID) {
             case ID_WIKI_EDITING_MAIN_PAGE:
-                sprintf(buf, "ID_WIKI_EDITING_MAIN_PAGE %p", pHandlerInfo);
                 handler = std::bind(CMainFrame_OpenHelp, this_);
                 break;
             case ID_WIKI_HOTKEYS: