refactor: Use std::format

benchmark/benchmark.cpp

@@ -15,6 +15,7 @@
 #include <algorithm>
 #include <chrono>
 #include <ctime>
+#include <format>
 #include <iostream>
 #include <limits>
 #include <optional>
@@ -411,8 +412,11 @@ class bench
             if (bc.message.empty())
                 return "";
 
-            return "[" + bc.message + " " + std::to_string(iteration) + "/(" + std::to_string(bc.start_range) + "-"
-                + std::to_string(bc.end_range ? bc.end_range - 1 : bc.end_range) + ")] ";
+            return std::format("[{} {}/({}-{})]",
+                bc.message,
+                iteration,
+                bc.start_range,
+                bc.end_range ? bc.end_range - 1 : bc.end_range);
         }
     };
 

language_server/src/dap/dap_feature.cpp

@@ -14,6 +14,7 @@
 
 #include "dap_feature.h"
 
+#include <format>
 #include <functional>
 
 #include "nlohmann/json.hpp"
@@ -133,7 +134,7 @@ void dap_feature::mnote(unsigned char level, std::string_view text)
     response_->notify("output",
         nlohmann::json {
             { "category", "stderr" },
-            { "output", (std::to_string(level) + ":").append(text).append("\n") },
+            { "output", std::format("{}:{}\n", level, text) },
         });
 }
 
@@ -142,7 +143,7 @@ void dap_feature::punch(std::string_view text)
     response_->notify("output",
         nlohmann::json {
             { "category", "stdout" },
-            { "output", std::string(text).append("\n") },
+            { "output", std::format("{}\n", text) },
         });
 }
 

language_server/src/dap/dap_message_wrappers.cpp

@@ -14,6 +14,8 @@
 
 #include "dap_message_wrappers.h"
 
+#include <format>
+
 #include "nlohmann/json.hpp"
 
 namespace hlasm_plugin::language_server::dap {
@@ -33,18 +35,24 @@ std::optional<nlohmann::json> message_unwrapper::read()
 
 void message_wrapper::write(const nlohmann::json& msg)
 {
-    target.write(
-        nlohmann::json { { "jsonrpc", "2.0" }, { "method", generate_method_name(session_id) }, { "params", msg } });
+    target.write(nlohmann::json {
+        { "jsonrpc", "2.0" },
+        { "method", generate_method_name(session_id) },
+        { "params", msg },
+    });
 }
 
 void message_wrapper::write(nlohmann::json&& msg)
 {
     target.write(nlohmann::json {
-        { "jsonrpc", "2.0" }, { "method", generate_method_name(session_id) }, { "params", std::move(msg) } });
+        { "jsonrpc", "2.0" },
+        { "method", generate_method_name(session_id) },
+        { "params", std::move(msg) },
+    });
 }
 
 std::string message_wrapper::generate_method_name(size_t id)
 {
-    return std::string(broadcom_tunnel_method) + '/' + std::to_string(id);
+    return std::format("{}/{}", broadcom_tunnel_method, id);
 }
 } // namespace hlasm_plugin::language_server::dap

language_server/src/feature.cpp

@@ -14,6 +14,8 @@
 
 #include "feature.h"
 
+#include <format>
+
 #include "nlohmann/json.hpp"
 
 void nlohmann::adl_serializer<hlasm_plugin::language_server::request_id>::to_json(
@@ -70,4 +72,12 @@ nlohmann::json feature::position_to_json(const parser_library::position& positio
     return nlohmann::json { { "line", position.line }, { "character", position.column } };
 }
 
+std::string request_id::to_string() const
+{
+    if (std::holds_alternative<long>(id))
+        return std::format("({})", std::get<long>(id));
+    else
+        return std::format("\"{}\"", std::get<std::string>(id));
+}
+
 } // namespace hlasm_plugin::language_server

language_server/src/feature.h

@@ -47,13 +47,7 @@ class request_id
 
     auto operator<=>(const request_id&) const = default;
 
-    std::string to_string() const
-    {
-        if (std::holds_alternative<long>(id))
-            return "(" + std::to_string(std::get<long>(id)) + ")";
-        else
-            return "\"" + std::get<std::string>(id) + "\"";
-    }
+    std::string to_string() const;
 
     auto hash() const { return std::hash<std::variant<long, std::string>>()(id); }
 

parser_library/src/aread_time.cpp

@@ -14,31 +14,20 @@
 
 #include "aread_time.h"
 
-namespace {
-std::string zero_left_pad(std::string s, size_t len)
-{
-    if (s.size() >= len)
-        return s;
-
-    s.insert(s.begin(), len - s.size(), '0');
-    return s;
-}
-} // namespace
-
+#include <format>
 
 std::string hlasm_plugin::parser_library::time_to_clockb(std::chrono::nanoseconds d)
 {
     using namespace std::chrono;
-    return zero_left_pad(std::to_string(duration_cast<milliseconds>(d).count() / 10), 8);
+    return std::format("{:08}", duration_cast<milliseconds>(d).count() / 10);
 }
 
 std::string hlasm_plugin::parser_library::time_to_clockd(std::chrono::nanoseconds d)
 {
     using namespace std::chrono;
-    std::string result;
-    result.append(zero_left_pad(std::to_string(duration_cast<hours>(d).count()), 2));
-    result.append(zero_left_pad(std::to_string(duration_cast<minutes>(d).count() % 60), 2));
-    result.append(zero_left_pad(std::to_string(duration_cast<seconds>(d).count() % 60), 2));
-    result.append(zero_left_pad(std::to_string(duration_cast<milliseconds>(d).count() % 1000 / 10), 2));
-    return result;
+    return std::format("{:02}{:02}{:02}{:02}",
+        duration_cast<hours>(d).count(),
+        duration_cast<minutes>(d).count() % 60,
+        duration_cast<seconds>(d).count() % 60,
+        duration_cast<milliseconds>(d).count() % 1000 / 10);
 }

parser_library/src/context/hlasm_context.cpp

@@ -15,6 +15,7 @@
 #include "hlasm_context.h"
 
 #include <ctime>
+#include <format>
 #include <memory>
 #include <numeric>
 
@@ -69,14 +70,6 @@ void hlasm_context::init_instruction_map(opcode_map& opcodes, id_storage& ids, i
 }
 
 namespace {
-std::string left_pad(std::string s, size_t len, char c = ' ')
-{
-    if (auto string_len = s.length(); string_len < len)
-        s.insert(0, len - string_len, c);
-
-    return s;
-}
-
 class sysstmt_macro_param_data : public macro_param_data_single_dynamic
 {
     const performance_metrics& metrics;
@@ -96,7 +89,7 @@ class sysstmt_macro_param_data : public macro_param_data_single_dynamic
         size_t sysstmt = metrics.macro_def_statements + metrics.macro_statements + metrics.open_code_statements
             + metrics.copy_statements + adjustment;
 
-        return left_pad(std::to_string(sysstmt), 8, '0');
+        return std::format("{:08}", sysstmt);
     };
 
     explicit sysstmt_macro_param_data(const performance_metrics& metrics, const std::deque<code_scope>& scope_stack)
@@ -153,37 +146,11 @@ auto time_sysvars(utils::timestamp now)
         std::string datc_val;
         std::string date_val;
         std::string systime;
-    } result;
-    auto& [datc_val, date_val, systime] = result;
-    auto year = std::to_string(now.year());
-    auto month = std::to_string(now.month());
-    auto day = std::to_string(now.day());
-    if (now.month() < 10)
-        month.insert(0, 1, '0');
-    if (now.day() < 10)
-        day.insert(0, 1, '0');
-
-    datc_val.reserve(8);
-    date_val.reserve(8);
-
-    datc_val.append(year);
-    datc_val.append(month);
-    datc_val.append(day);
-
-    date_val.append(month);
-    date_val.push_back('/');
-    date_val.append(day);
-    date_val.push_back('/');
-    date_val.append(year.c_str() + 2);
-
-    if (now.hour() < 10)
-        systime.push_back('0');
-    systime.append(std::to_string(now.hour()));
-    systime.push_back(':');
-    if (now.minute() < 10)
-        systime.push_back('0');
-    systime.append(std::to_string(now.minute()));
-
+    } result = {
+        std::format("{:04}{:02}{:02}", now.year(), now.month(), now.day()),
+        std::format("{:02}/{:02}/{:02}", now.month(), now.day(), now.year() % 100),
+        std::format("{:02}.{:02}", now.hour(), now.minute()),
+    };
     return result;
 }
 
@@ -243,9 +210,8 @@ void hlasm_context::add_global_system_variables(system_variable_map& sysvars)
     static constexpr const auto emulated_asm_name = "HIGH LEVEL ASSEMBLER";
     sysvars.insert(create_system_variable(id_index("SYSASM"), emulated_asm_name, true));
 
-    sysvars.insert(create_system_variable(id_index("SYSM_HSEV"),
-        create_dynamic_var([this]() { return left_pad(std::to_string(mnote_max), 3, '0'); }),
-        true));
+    sysvars.insert(create_system_variable(
+        id_index("SYSM_HSEV"), create_dynamic_var([this]() { return std::format("{:03}", mnote_max); }), true));
 }
 
 void hlasm_context::add_scoped_system_variables(system_variable_map& sysvars, size_t skip_last, bool globals_only)
@@ -263,7 +229,7 @@ void hlasm_context::add_scoped_system_variables(system_variable_map& sysvars, si
     } view { *this, skip_last };
 
     sysvars.insert(create_system_variable(id_index("SYSM_SEV"),
-        create_dynamic_var([view]() { return left_pad(std::to_string(view.top().mnote_last_max), 3, '0'); }),
+        create_dynamic_var([view]() { return std::format("{:03}", view.top().mnote_last_max); }),
         true));
 
     if (globals_only)
@@ -279,9 +245,8 @@ void hlasm_context::add_scoped_system_variables(system_variable_map& sysvars, si
         }),
         false));
 
-    sysvars.insert(create_system_variable(id_index("SYSNDX"),
-        create_dynamic_var([view]() { return left_pad(std::to_string(view.top().sysndx), 4, '0'); }),
-        false));
+    sysvars.insert(create_system_variable(
+        id_index("SYSNDX"), create_dynamic_var([view]() { return std::format("{:04}", view.top().sysndx); }), false));
 
     sysvars.insert(create_system_variable(id_index("SYSSTYP"),
         create_dynamic_var([view]() -> std::string {

parser_library/src/diagnostic_tools.cpp

@@ -14,6 +14,7 @@
 
 #include "diagnostic_tools.h"
 
+#include <format>
 #include <string>
 #include <utility>
 
@@ -33,7 +34,7 @@ diagnostic add_stack_details(diagnostic_op d, context::processing_stack_t stack)
     {
         const auto& f = stack.frame();
         diag.related.emplace_back(range_uri(f.resource_loc->get_uri(), range(f.pos)),
-            "While compiling " + f.resource_loc->to_presentable() + '(' + std::to_string(f.pos.line + 1) + ")");
+            std::format("While compiling {}({})", f.resource_loc->to_presentable(), f.pos.line + 1));
     }
 
     return diag;

parser_library/src/expressions/nominal_value.cpp

@@ -84,8 +84,8 @@ size_t nominal_value_exprs::hash() const
     {
         result = hash_combine(result,
             std::visit(
-                [](const auto& v) {
-                    if constexpr (std::is_same_v<decltype(v), const mach_expr_ptr&>)
+                []<typename V>(const V& v) {
+                    if constexpr (std::is_same_v<V, mach_expr_ptr>)
                         return v->hash();
                     else
                         return v.hash();
@@ -152,8 +152,8 @@ bool is_similar(const nominal_value_exprs& left, const nominal_value_exprs& righ
     for (size_t i = 0; i < left.exprs.size(); ++i)
     {
         if (!std::visit(
-                [](const auto& l, const auto& r) {
-                    if constexpr (std::is_same_v<decltype(l), decltype(r)>)
+                []<typename L, typename R>(const L& l, const R& r) {
+                    if constexpr (std::is_same_v<L, R>)
                         return utils::is_similar(l, r);
                     else
                         return false;

parser_library/src/lexing/token.cpp

@@ -15,6 +15,7 @@
 #include "token.h"
 
 #include <CharStream.h>
+#include <format>
 
 #include <misc/Interval.h>
 
@@ -58,13 +59,6 @@ void replace_all(std::string& str, std::string const& from, std::string const& t
 
 std::string token::toString() const
 {
-    std::stringstream ss;
-
-    std::string channel_str;
-    if (channel_ > 0)
-    {
-        channel_str = ",channel=" + std::to_string(channel_);
-    }
     std::string txt = getText();
     if (!txt.empty())
     {
@@ -77,11 +71,13 @@ std::string token::toString() const
         txt = "<no text>";
     }
 
-    std::string type_string = std::to_string(static_cast<ssize_t>(type_));
-
-    ss << "[@" << static_cast<ssize_t>(getTokenIndex()) << "," << static_cast<ssize_t>(start_) << ":"
-       << static_cast<ssize_t>(stop_) << "='" << txt << "',<" << type_string << ">" << channel_str << "," << line_
-       << ":" << getCharPositionInLine() << "]";
-
-    return ss.str();
+    return std::format("[@{},{}:{}='{}',<{}>,channel={},{}:{}]",
+        static_cast<ssize_t>(getTokenIndex()),
+        static_cast<ssize_t>(start_),
+        static_cast<ssize_t>(stop_),
+        std::move(txt),
+        static_cast<ssize_t>(type_),
+        channel_,
+        line_,
+        getCharPositionInLine());
 }