Merge pull request #1 from Masterkatze/sniper

Masterkatze · web-flow · commit 5c38c2de4ddf · 2025-03-12T02:01:28.000+03:00
Use sniper docker container
diff --git a/.github/workflows/cibuild.yml b/.github/workflows/cibuild.yml
@@ -17,15 +17,23 @@ jobs:
       run:
         shell: bash
 
+    container:
+      image: 'registry.gitlab.steamos.cloud/steamrt/sniper/sdk:latest'
+
     steps:
     - uses: actions/checkout@v4
       with:
         submodules: recursive
 
+    - name: Set ownership
+      run: |
+        # Fix for "detected dubious ownership in repository"
+        chown -R $(id -u):$(id -g) $PWD
+
     - name: Set reusable strings
       run: |
         preset_name=linux-release
-        workspace_dir=${{ github.workspace }}
+        workspace_dir="$GITHUB_WORKSPACE"
         source_dir=${workspace_dir}
         build_dir=${workspace_dir}/build/$preset_name
         install_dir=$build_dir/install
@@ -34,11 +42,6 @@ jobs:
         echo "install_dir=$install_dir" >> "$GITHUB_ENV"
         echo "preset_name=$preset_name" >> "$GITHUB_ENV"
 
-    - name: Install packages
-      run: |
-        sudo apt update
-        sudo apt install libelf-dev ninja-build -y
-
     - name: Git fetch tags
       run: git fetch origin --tags
 
diff --git a/.gitmodules b/.gitmodules
@@ -1,3 +1,6 @@
 [submodule "external/CLI11"]
 	path = external/CLI11
 	url = https://github.com/CLIUtils/CLI11.git
+[submodule "fmt"]
+	path = external/fmt
+	url = https://github.com/fmtlib/fmt
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,15 +1,16 @@
-cmake_minimum_required(VERSION 3.31)
+cmake_minimum_required(VERSION 3.25)
 
 project(gamedata-gen LANGUAGES CXX)
 
 find_package(PkgConfig)
 
-set(CMAKE_CXX_STANDARD 23)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 pkg_check_modules(libelf libelf REQUIRED IMPORTED_TARGET)
 
 add_subdirectory(external/CLI11)
+add_subdirectory(external/fmt)
 
 add_executable(gamedata-gen)
 
@@ -30,6 +31,7 @@ target_link_libraries(gamedata-gen
     PRIVATE
     PkgConfig::libelf
     CLI11::CLI11
+    fmt::fmt
 )
 
 install(
diff --git a/external/fmt b/external/fmt
@@ -0,0 +1 @@
+Subproject commit 77c0fc07d912ead06aaf9f2aaa5611a29139779e
diff --git a/src/formatter.cpp b/src/formatter.cpp
@@ -1,5 +1,7 @@
 #include "formatter.hpp"
 
+#include <algorithm>
+
 bool shouldSkipWindowsFunction(const ClassInfo &classInfo, std::size_t vtableIndex, std::size_t functionIndex, const FunctionInfo &functionInfo)
 {
     if (functionInfo.name.starts_with('~'))
diff --git a/src/main.cpp b/src/main.cpp
@@ -4,10 +4,12 @@
 #include "writer.hpp"
 
 #include "CLI/CLI.hpp"
+#include <fmt/core.h>
 
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <fcntl.h>
+#include <unistd.h>
 
 #include <cassert>
 #include <cstring>
@@ -20,13 +22,13 @@ class mmapReader
         auto fd = ::open(path.c_str(), O_RDONLY);
         if(fd == -1)
         {
-            throw std::runtime_error(std::format("Failed to open file \"{}\": {} (errno={}) ", path, strerror(errno), errno));
+            throw std::runtime_error(fmt::format("Failed to open file \"{}\": {} (errno={}) ", path, strerror(errno), errno));
         }
 
         struct stat sb {};
         if(fstat(fd, &sb) == -1)
         {
-            throw std::runtime_error(std::format("stat failed for file \"{}\": {} (errno={}) ", path, strerror(errno), errno));
+            throw std::runtime_error(fmt::format("stat failed for file \"{}\": {} (errno={}) ", path, strerror(errno), errno));
         }
 
         auto file_size = static_cast<std::size_t>(sb.st_size);
@@ -46,7 +48,7 @@ class mmapReader
         {
             if(data == MAP_FAILED)
             {
-                throw std::runtime_error(std::format("mmap failed for file \"{}\": {} (errno={}) ", path, strerror(errno), errno));
+                throw std::runtime_error(fmt::format("mmap failed for file \"{}\": {} (errno={}) ", path, strerror(errno), errno));
             }
         }
 
@@ -66,26 +68,26 @@ class mmapReader
             auto res = madvise(reinterpret_cast<void*>(m_data), m_mem_size, MADV_DONTNEED | MADV_FREE);
             if(res == -1)
             {
-                std::cout << std::format("madvise failed: {} (errno={}) ", strerror(errno), errno);
+                std::cout << fmt::format("madvise failed: {} (errno={}) ", strerror(errno), errno);
             }
 
             res = munmap(reinterpret_cast<void*>(m_data), m_mem_size);
             if(res != 0)
             {
-                std::cout << std::format("munmap failed with result {}: {} (errno={}) ", res, strerror(errno), errno);
+                std::cout << fmt::format("munmap failed with result {}: {} (errno={}) ", res, strerror(errno), errno);
             }
         }
 
         auto res = posix_fadvise(m_fd, 0, static_cast<off_t>(m_file_size), POSIX_FADV_DONTNEED); //POSIX_FADV_NOREUSE
         if(res != 0)
         {
-            std::cout << std::format("posix_fadvise failed: {} (errno={}) ", strerror(errno), errno);
+            std::cout << fmt::format("posix_fadvise failed: {} (errno={}) ", strerror(errno), errno);
         }
 
         res = ::close(m_fd);
         if(res == -1)
         {
-            std::cout << std::format("Failed to close file descriptor {}: {} (errno={}) ", m_fd, strerror(errno), errno);
+            std::cout << fmt::format("Failed to close file descriptor {}: {} (errno={}) ", m_fd, strerror(errno), errno);
         }
     }
 
@@ -136,7 +138,7 @@ int main(int argc, char *argv[])
 
     if (outputDirectoryPaths.empty() && !dumpOffsets && !dumpSignatures)
     {
-        std::cerr << std::format("Specify either --output or one of --dump_* options") << std::endl;
+        std::cerr << fmt::format("Specify either --output or one of --dump_* options") << std::endl;
         return EXIT_FAILURE;
     }
 
@@ -155,7 +157,7 @@ int main(int argc, char *argv[])
 
     if (!programInfo.error.empty())
     {
-        std::cerr << std::format("Failed to process input file '{}': {}", libraryPath, programInfo.error) << std::endl;
+        std::cerr << fmt::format("Failed to process input file '{}': {}", libraryPath, programInfo.error) << std::endl;
         return EXIT_FAILURE;
     }
 
@@ -196,7 +198,7 @@ int main(int argc, char *argv[])
             for (const auto& function : vtable.functions)
             {
                 std::string shortName = function->shortName.empty() ? "?" : function->shortName;
-                std::cout << std::format("    [{}] {} ({}::{})", function->id, function->name, function->nameSpace, shortName) << std::endl;
+                std::cout << fmt::format("    [{}] {} ({}::{})", function->id, function->name, function->nameSpace, shortName) << std::endl;
             }
         }
     }
@@ -223,7 +225,7 @@ int main(int argc, char *argv[])
                     windowsIndex = std::to_string(function.windowsIndex.value());
                 }
 
-                std::cout << std::format("{}::{} {} {} {}", outClass.name, function.name, (function.isMulti ? " [Multi]" : ""), linuxIndex, windowsIndex) << std::endl;
+                std::cout << fmt::format("{}::{} {} {} {}", outClass.name, function.name, (function.isMulti ? " [Multi]" : ""), linuxIndex, windowsIndex) << std::endl;
             }
         }
     }
@@ -240,7 +242,7 @@ int main(int argc, char *argv[])
             auto demangledSymbol = demangleSymbol(symbol.name.c_str());
             auto demangledSymbolText = demangledSymbol ? &*demangledSymbol : symbol.name.c_str();
 
-            std::cout << std::format("{} {}", demangledSymbolText, symbol.name) << std::endl;
+            std::cout << fmt::format("{} {}", demangledSymbolText, symbol.name) << std::endl;
         }
     }
 
diff --git a/src/reader.cpp b/src/reader.cpp
@@ -44,7 +44,7 @@ bool LargeNumber::operator!=(const LargeNumber& other) const
 
 std::ostream& operator<<(std::ostream& os, const LargeNumber& number)
 {
-    os << std::format("{:#018x}", static_cast<unsigned long long>(number));
+    os << fmt::format("{:#018x}", static_cast<unsigned long long>(number));
     return os;
 }
 
diff --git a/src/reader.hpp b/src/reader.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
-#include <format>
+#include <fmt/format.h>
+
 #include <iostream>
 #include <string>
 #include <vector>
@@ -21,11 +22,11 @@ struct LargeNumber
 std::ostream& operator<<(std::ostream& os, const LargeNumber& number);
 
 template <>
-struct std::formatter<LargeNumber> : formatter<std::string>
+struct fmt::formatter<LargeNumber> : formatter<std::string>
 {
     auto format(LargeNumber number, format_context& ctx) const
     {
-        return formatter<std::string>::format(std::format("{:#018x}", static_cast<unsigned long long>(number)), ctx);
+        return formatter<std::string>::format(fmt::format("{:#018x}", static_cast<unsigned long long>(number)), ctx);
     }
 };
 
diff --git a/src/writer.cpp b/src/writer.cpp
@@ -31,13 +31,13 @@ Offsets prepareOffsets(std::list<ClassInfo>& classes)
         {
             if (!function.linuxIndex.has_value())
             {
-                // std::cerr << std::format("Warning: function {} has no linuxIndex value", function.name) << std::endl;
+                // std::cerr << fmt::format("Warning: function {} has no linuxIndex value", function.name) << std::endl;
                 continue;
             }
 
             if (!function.windowsIndex.has_value())
             {
-                // std::cerr << std::format("Warning: function {} has no windowsIndex value", function.name) << std::endl;
+                // std::cerr << fmt::format("Warning: function {} has no windowsIndex value", function.name) << std::endl;
                 continue;
             }
 
@@ -55,21 +55,21 @@ std::optional<int> getOffset(Offsets offsets, const std::string& symbol)
     auto functionNameStartPos = symbol.rfind("::");
     if (functionNameStartPos == std::string::npos)
     {
-        std::cerr << std::format("Error: incorrect format of symbol {} (missing \'::\' separator)", symbol) << std::endl;
+        std::cerr << fmt::format("Error: incorrect format of symbol {} (missing \'::\' separator)", symbol) << std::endl;
         return std::nullopt;
     }
 
     auto systemNameStartPos = symbol.rfind('.');
     if (systemNameStartPos == std::string::npos)
     {
-        std::cerr << std::format("Error: incorrect format of symbol {} (missing \'.\' separator)", symbol) << std::endl;
+        std::cerr << fmt::format("Error: incorrect format of symbol {} (missing \'.\' separator)", symbol) << std::endl;
         return std::nullopt;
     }
 
     auto namespaceStartPos = symbol.find("::");
     if (namespaceStartPos == std::string::npos)
     {
-        std::cerr << std::format("Error: incorrect format of symbol {} (missing \'::\' separator)", symbol) << std::endl;
+        std::cerr << fmt::format("Error: incorrect format of symbol {} (missing \'::\' separator)", symbol) << std::endl;
         return std::nullopt;
     }
 
@@ -81,23 +81,23 @@ std::optional<int> getOffset(Offsets offsets, const std::string& symbol)
     auto classVTablesIterator = offsets.find(className);
     if (classVTablesIterator == offsets.end())
     {
-        std::cerr << std::format("Error: failed to find class vtable by its name \'{}\')", className) << std::endl;
+        std::cerr << fmt::format("Error: failed to find class vtable by its name \'{}\')", className) << std::endl;
         return std::nullopt;
     }
     const auto& classVTables = classVTablesIterator->second;
 
     auto classNamespaceIterator = classVTables.find(namespaceName);
     if (classNamespaceIterator == classVTables.end())
     {
-        std::cerr << std::format("Error: failed to find class namespace by its name \'{}\')", namespaceName) << std::endl;
+        std::cerr << fmt::format("Error: failed to find class namespace by its name \'{}\')", namespaceName) << std::endl;
         return std::nullopt;
     }
     const auto& classNamespace = classNamespaceIterator->second;
 
     auto functionIterator = classNamespace.find(functionName);
     if (functionIterator == classNamespace.end())
     {
-        std::cerr << std::format("Error: failed to find function by its name \'{}\'", functionName) << std::endl;
+        std::cerr << fmt::format("Error: failed to find function by its name \'{}\'", functionName) << std::endl;
         return std::nullopt;
     }
     const auto& function = functionIterator->second;
@@ -126,14 +126,14 @@ int writeGamedataFile(std::list<ClassInfo>& classes, const std::vector<std::file
 
         if (inputFileExtension != inputFileExtensionString)
         {
-            std::cerr << std::format("Error: input file {} doesn't contain correct file extension {}", inputFilePath.string(), inputFileExtension.string()) << std::endl;
+            std::cerr << fmt::format("Error: input file {} doesn't contain correct file extension {}", inputFilePath.string(), inputFileExtension.string()) << std::endl;
             return EXIT_FAILURE;
         }
 
         std::ifstream inputStream(inputFilePath);
         if (!inputStream)
         {
-            std::cerr << std::format("Error: input file {} open failed - {}", inputFilePath.string(), std::strerror(errno)) << std::endl;
+            std::cerr << fmt::format("Error: input file {} open failed - {}", inputFilePath.string(), std::strerror(errno)) << std::endl;
             return EXIT_FAILURE;
         }
 
@@ -144,7 +144,7 @@ int writeGamedataFile(std::list<ClassInfo>& classes, const std::vector<std::file
 
         if (!std::filesystem::exists(outputFileDir))
         {
-            std::cerr << std::format("Error: failed to create {} directory", outputFileDir.string(), std::strerror(errno)) << std::endl;
+            std::cerr << fmt::format("Error: failed to create {} directory", outputFileDir.string(), std::strerror(errno)) << std::endl;
             return EXIT_FAILURE;
         }
 
@@ -153,7 +153,7 @@ int writeGamedataFile(std::list<ClassInfo>& classes, const std::vector<std::file
         std::ofstream outputStream(outputFile);
         if (!outputStream)
         {
-            std::cerr << std::format("Error: output file {} open failed - {}", outputFile.string(), std::strerror(errno)) << std::endl;
+            std::cerr << fmt::format("Error: output file {} open failed - {}", outputFile.string(), std::strerror(errno)) << std::endl;
             return EXIT_FAILURE;
         }
 
@@ -169,21 +169,21 @@ int writeGamedataFile(std::list<ClassInfo>& classes, const std::vector<std::file
                 auto endPos = line.rfind('#');
                 if (endPos == startPos)
                 {
-                    std::cerr << std::format("Error: input file {} contains only one \'#\' at line {}", inputFilePath.string(), lineNumber) << std::endl;
+                    std::cerr << fmt::format("Error: input file {} contains only one \'#\' at line {}", inputFilePath.string(), lineNumber) << std::endl;
                     return EINVAL;
                 }
 
                 auto symbol = line.substr(startPos + 1, endPos - startPos - 1);
                 if (symbol.empty())
                 {
-                    std::cerr << std::format("Error: symbol from input file {} at line {} is empty somehow", inputFilePath.string(), lineNumber) << std::endl;
+                    std::cerr << fmt::format("Error: symbol from input file {} at line {} is empty somehow", inputFilePath.string(), lineNumber) << std::endl;
                     return EINVAL;
                 }
 
                 auto offset = getOffset(offsets, symbol);
                 if (!offset.has_value())
                 {
-                    std::cerr << std::format("Error: failed to get offset of symbol {} from input file {} at line {}", symbol, inputFilePath.string(), lineNumber) << std::endl;
+                    std::cerr << fmt::format("Error: failed to get offset of symbol {} from input file {} at line {}", symbol, inputFilePath.string(), lineNumber) << std::endl;
                     return EINVAL;
                 }
 

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,7 @@`
`1`	`1`	`#include "formatter.hpp"`
`2`	`2`
	`3`	`+#include <algorithm>`
	`4`	`+`
`3`	`5`	`bool shouldSkipWindowsFunction(const ClassInfo &classInfo, std::size_t vtableIndex, std::size_t functionIndex, const FunctionInfo &functionInfo)`
`4`	`6`	`{`
`5`	`7`	`if (functionInfo.name.starts_with('~'))`
Original file line number	Diff line number	Diff line change
`@@ -4,10 +4,12 @@`
`4`	`4`	`#include "writer.hpp"`
`5`	`5`
`6`	`6`	`#include "CLI/CLI.hpp"`
	`7`	`+#include <fmt/core.h>`
`7`	`8`
`8`	`9`	`#include <sys/mman.h>`
`9`	`10`	`#include <sys/stat.h>`
`10`	`11`	`#include <fcntl.h>`
	`12`	`+#include <unistd.h>`
`11`	`13`
`12`	`14`	`#include <cassert>`
`13`	`15`	`#include <cstring>`
`@@ -20,13 +22,13 @@ class mmapReader`
`20`	`22`	`auto fd = ::open(path.c_str(), O_RDONLY);`
`21`	`23`	`if(fd == -1)`
`22`	`24`	`{`
`23`		`- throw std::runtime_error(std::format("Failed to open file \"{}\": {} (errno={}) ", path, strerror(errno), errno));`
	`25`	`+ throw std::runtime_error(fmt::format("Failed to open file \"{}\": {} (errno={}) ", path, strerror(errno), errno));`
`24`	`26`	`}`
`25`	`27`
`26`	`28`	`struct stat sb {};`
`27`	`29`	`if(fstat(fd, &sb) == -1)`
`28`	`30`	`{`
`29`		`- throw std::runtime_error(std::format("stat failed for file \"{}\": {} (errno={}) ", path, strerror(errno), errno));`
	`31`	`+ throw std::runtime_error(fmt::format("stat failed for file \"{}\": {} (errno={}) ", path, strerror(errno), errno));`
`30`	`32`	`}`
`31`	`33`
`32`	`34`	`auto file_size = static_cast<std::size_t>(sb.st_size);`
`@@ -46,7 +48,7 @@ class mmapReader`
`46`	`48`	`{`
`47`	`49`	`if(data == MAP_FAILED)`
`48`	`50`	`{`
`49`		`- throw std::runtime_error(std::format("mmap failed for file \"{}\": {} (errno={}) ", path, strerror(errno), errno));`
	`51`	`+ throw std::runtime_error(fmt::format("mmap failed for file \"{}\": {} (errno={}) ", path, strerror(errno), errno));`
`50`	`52`	`}`
`51`	`53`	`}`
`52`	`54`
`@@ -66,26 +68,26 @@ class mmapReader`
`66`	`68`	`auto res = madvise(reinterpret_cast<void*>(m_data), m_mem_size, MADV_DONTNEED \| MADV_FREE);`
`67`	`69`	`if(res == -1)`
`68`	`70`	`{`
`69`		`- std::cout << std::format("madvise failed: {} (errno={}) ", strerror(errno), errno);`
	`71`	`+ std::cout << fmt::format("madvise failed: {} (errno={}) ", strerror(errno), errno);`
`70`	`72`	`}`
`71`	`73`
`72`	`74`	`res = munmap(reinterpret_cast<void*>(m_data), m_mem_size);`
`73`	`75`	`if(res != 0)`
`74`	`76`	`{`
`75`		`- std::cout << std::format("munmap failed with result {}: {} (errno={}) ", res, strerror(errno), errno);`
	`77`	`+ std::cout << fmt::format("munmap failed with result {}: {} (errno={}) ", res, strerror(errno), errno);`
`76`	`78`	`}`
`77`	`79`	`}`
`78`	`80`
`79`	`81`	`auto res = posix_fadvise(m_fd, 0, static_cast<off_t>(m_file_size), POSIX_FADV_DONTNEED); //POSIX_FADV_NOREUSE`
`80`	`82`	`if(res != 0)`
`81`	`83`	`{`
`82`		`- std::cout << std::format("posix_fadvise failed: {} (errno={}) ", strerror(errno), errno);`
	`84`	`+ std::cout << fmt::format("posix_fadvise failed: {} (errno={}) ", strerror(errno), errno);`
`83`	`85`	`}`
`84`	`86`
`85`	`87`	`res = ::close(m_fd);`
`86`	`88`	`if(res == -1)`
`87`	`89`	`{`
`88`		`- std::cout << std::format("Failed to close file descriptor {}: {} (errno={}) ", m_fd, strerror(errno), errno);`
	`90`	`+ std::cout << fmt::format("Failed to close file descriptor {}: {} (errno={}) ", m_fd, strerror(errno), errno);`
`89`	`91`	`}`
`90`	`92`	`}`
`91`	`93`
`@@ -136,7 +138,7 @@ int main(int argc, char *argv[])`
`136`	`138`
`137`	`139`	`if (outputDirectoryPaths.empty() && !dumpOffsets && !dumpSignatures)`
`138`	`140`	`{`
`139`		`- std::cerr << std::format("Specify either --output or one of --dump_* options") << std::endl;`
	`141`	`+ std::cerr << fmt::format("Specify either --output or one of --dump_* options") << std::endl;`
`140`	`142`	`return EXIT_FAILURE;`
`141`	`143`	`}`
`142`	`144`
`@@ -155,7 +157,7 @@ int main(int argc, char *argv[])`
`155`	`157`
`156`	`158`	`if (!programInfo.error.empty())`
`157`	`159`	`{`
`158`		`- std::cerr << std::format("Failed to process input file '{}': {}", libraryPath, programInfo.error) << std::endl;`
	`160`	`+ std::cerr << fmt::format("Failed to process input file '{}': {}", libraryPath, programInfo.error) << std::endl;`
`159`	`161`	`return EXIT_FAILURE;`
`160`	`162`	`}`
`161`	`163`
`@@ -196,7 +198,7 @@ int main(int argc, char *argv[])`
`196`	`198`	`for (const auto& function : vtable.functions)`
`197`	`199`	`{`
`198`	`200`	`std::string shortName = function->shortName.empty() ? "?" : function->shortName;`
`199`		`- std::cout << std::format(" [{}] {} ({}::{})", function->id, function->name, function->nameSpace, shortName) << std::endl;`
	`201`	`+ std::cout << fmt::format(" [{}] {} ({}::{})", function->id, function->name, function->nameSpace, shortName) << std::endl;`
`200`	`202`	`}`
`201`	`203`	`}`
`202`	`204`	`}`
`@@ -223,7 +225,7 @@ int main(int argc, char *argv[])`
`223`	`225`	`windowsIndex = std::to_string(function.windowsIndex.value());`
`224`	`226`	`}`
`225`	`227`
`226`		`- std::cout << std::format("{}::{} {} {} {}", outClass.name, function.name, (function.isMulti ? " [Multi]" : ""), linuxIndex, windowsIndex) << std::endl;`
	`228`	`+ std::cout << fmt::format("{}::{} {} {} {}", outClass.name, function.name, (function.isMulti ? " [Multi]" : ""), linuxIndex, windowsIndex) << std::endl;`
`227`	`229`	`}`
`228`	`230`	`}`
`229`	`231`	`}`
`@@ -240,7 +242,7 @@ int main(int argc, char *argv[])`
`240`	`242`	`auto demangledSymbol = demangleSymbol(symbol.name.c_str());`
`241`	`243`	`auto demangledSymbolText = demangledSymbol ? &*demangledSymbol : symbol.name.c_str();`
`242`	`244`
`243`		`- std::cout << std::format("{} {}", demangledSymbolText, symbol.name) << std::endl;`
	`245`	`+ std::cout << fmt::format("{} {}", demangledSymbolText, symbol.name) << std::endl;`
`244`	`246`	`}`
`245`	`247`	`}`
`246`	`248`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ bool LargeNumber::operator!=(const LargeNumber& other) const`
`44`	`44`
`45`	`45`	`std::ostream& operator<<(std::ostream& os, const LargeNumber& number)`
`46`	`46`	`{`
`47`		`- os << std::format("{:#018x}", static_cast<unsigned long long>(number));`
	`47`	`+ os << fmt::format("{:#018x}", static_cast<unsigned long long>(number));`
`48`	`48`	`return os;`
`49`	`49`	`}`
`50`	`50`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`#pragma once`
`2`	`2`
`3`		`-#include <format>`
	`3`	`+#include <fmt/format.h>`
	`4`	`+`
`4`	`5`	`#include <iostream>`
`5`	`6`	`#include <string>`
`6`	`7`	`#include <vector>`
`@@ -21,11 +22,11 @@ struct LargeNumber`
`21`	`22`	`std::ostream& operator<<(std::ostream& os, const LargeNumber& number);`
`22`	`23`
`23`	`24`	`template <>`
`24`		`-struct std::formatter<LargeNumber> : formatter<std::string>`
	`25`	`+struct fmt::formatter<LargeNumber> : formatter<std::string>`
`25`	`26`	`{`
`26`	`27`	`auto format(LargeNumber number, format_context& ctx) const`
`27`	`28`	`{`
`28`		`- return formatter<std::string>::format(std::format("{:#018x}", static_cast<unsigned long long>(number)), ctx);`
	`29`	`+ return formatter<std::string>::format(fmt::format("{:#018x}", static_cast<unsigned long long>(number)), ctx);`
`29`	`30`	`}`
`30`	`31`	`};`
`31`	`32`
Original file line number	Diff line number	Diff line change
`@@ -31,13 +31,13 @@ Offsets prepareOffsets(std::list<ClassInfo>& classes)`
`31`	`31`	`{`
`32`	`32`	`if (!function.linuxIndex.has_value())`
`33`	`33`	`{`
`34`		`- // std::cerr << std::format("Warning: function {} has no linuxIndex value", function.name) << std::endl;`
	`34`	`+ // std::cerr << fmt::format("Warning: function {} has no linuxIndex value", function.name) << std::endl;`
`35`	`35`	`continue;`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`if (!function.windowsIndex.has_value())`
`39`	`39`	`{`
`40`		`- // std::cerr << std::format("Warning: function {} has no windowsIndex value", function.name) << std::endl;`
	`40`	`+ // std::cerr << fmt::format("Warning: function {} has no windowsIndex value", function.name) << std::endl;`
`41`	`41`	`continue;`
`42`	`42`	`}`
`43`	`43`
`@@ -55,21 +55,21 @@ std::optional<int> getOffset(Offsets offsets, const std::string& symbol)`
`55`	`55`	`auto functionNameStartPos = symbol.rfind("::");`
`56`	`56`	`if (functionNameStartPos == std::string::npos)`
`57`	`57`	`{`
`58`		`- std::cerr << std::format("Error: incorrect format of symbol {} (missing \'::\' separator)", symbol) << std::endl;`
	`58`	`+ std::cerr << fmt::format("Error: incorrect format of symbol {} (missing \'::\' separator)", symbol) << std::endl;`
`59`	`59`	`return std::nullopt;`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`auto systemNameStartPos = symbol.rfind('.');`
`63`	`63`	`if (systemNameStartPos == std::string::npos)`
`64`	`64`	`{`
`65`		`- std::cerr << std::format("Error: incorrect format of symbol {} (missing \'.\' separator)", symbol) << std::endl;`
	`65`	`+ std::cerr << fmt::format("Error: incorrect format of symbol {} (missing \'.\' separator)", symbol) << std::endl;`
`66`	`66`	`return std::nullopt;`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`auto namespaceStartPos = symbol.find("::");`
`70`	`70`	`if (namespaceStartPos == std::string::npos)`
`71`	`71`	`{`
`72`		`- std::cerr << std::format("Error: incorrect format of symbol {} (missing \'::\' separator)", symbol) << std::endl;`
	`72`	`+ std::cerr << fmt::format("Error: incorrect format of symbol {} (missing \'::\' separator)", symbol) << std::endl;`
`73`	`73`	`return std::nullopt;`
`74`	`74`	`}`
`75`	`75`
`@@ -81,23 +81,23 @@ std::optional<int> getOffset(Offsets offsets, const std::string& symbol)`
`81`	`81`	`auto classVTablesIterator = offsets.find(className);`
`82`	`82`	`if (classVTablesIterator == offsets.end())`
`83`	`83`	`{`
`84`		`- std::cerr << std::format("Error: failed to find class vtable by its name \'{}\')", className) << std::endl;`
	`84`	`+ std::cerr << fmt::format("Error: failed to find class vtable by its name \'{}\')", className) << std::endl;`
`85`	`85`	`return std::nullopt;`
`86`	`86`	`}`
`87`	`87`	`const auto& classVTables = classVTablesIterator->second;`
`88`	`88`
`89`	`89`	`auto classNamespaceIterator = classVTables.find(namespaceName);`
`90`	`90`	`if (classNamespaceIterator == classVTables.end())`
`91`	`91`	`{`
`92`		`- std::cerr << std::format("Error: failed to find class namespace by its name \'{}\')", namespaceName) << std::endl;`
	`92`	`+ std::cerr << fmt::format("Error: failed to find class namespace by its name \'{}\')", namespaceName) << std::endl;`
`93`	`93`	`return std::nullopt;`
`94`	`94`	`}`
`95`	`95`	`const auto& classNamespace = classNamespaceIterator->second;`
`96`	`96`
`97`	`97`	`auto functionIterator = classNamespace.find(functionName);`
`98`	`98`	`if (functionIterator == classNamespace.end())`
`99`	`99`	`{`
`100`		`- std::cerr << std::format("Error: failed to find function by its name \'{}\'", functionName) << std::endl;`
	`100`	`+ std::cerr << fmt::format("Error: failed to find function by its name \'{}\'", functionName) << std::endl;`
`101`	`101`	`return std::nullopt;`
`102`	`102`	`}`
`103`	`103`	`const auto& function = functionIterator->second;`
`@@ -126,14 +126,14 @@ int writeGamedataFile(std::list<ClassInfo>& classes, const std::vector<std::file`
`126`	`126`
`127`	`127`	`if (inputFileExtension != inputFileExtensionString)`
`128`	`128`	`{`
`129`		`- std::cerr << std::format("Error: input file {} doesn't contain correct file extension {}", inputFilePath.string(), inputFileExtension.string()) << std::endl;`
	`129`	`+ std::cerr << fmt::format("Error: input file {} doesn't contain correct file extension {}", inputFilePath.string(), inputFileExtension.string()) << std::endl;`
`130`	`130`	`return EXIT_FAILURE;`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`std::ifstream inputStream(inputFilePath);`
`134`	`134`	`if (!inputStream)`
`135`	`135`	`{`
`136`		`- std::cerr << std::format("Error: input file {} open failed - {}", inputFilePath.string(), std::strerror(errno)) << std::endl;`
	`136`	`+ std::cerr << fmt::format("Error: input file {} open failed - {}", inputFilePath.string(), std::strerror(errno)) << std::endl;`
`137`	`137`	`return EXIT_FAILURE;`
`138`	`138`	`}`
`139`	`139`
`@@ -144,7 +144,7 @@ int writeGamedataFile(std::list<ClassInfo>& classes, const std::vector<std::file`
`144`	`144`
`145`	`145`	`if (!std::filesystem::exists(outputFileDir))`
`146`	`146`	`{`
`147`		`- std::cerr << std::format("Error: failed to create {} directory", outputFileDir.string(), std::strerror(errno)) << std::endl;`
	`147`	`+ std::cerr << fmt::format("Error: failed to create {} directory", outputFileDir.string(), std::strerror(errno)) << std::endl;`
`148`	`148`	`return EXIT_FAILURE;`
`149`	`149`	`}`
`150`	`150`
`@@ -153,7 +153,7 @@ int writeGamedataFile(std::list<ClassInfo>& classes, const std::vector<std::file`
`153`	`153`	`std::ofstream outputStream(outputFile);`
`154`	`154`	`if (!outputStream)`
`155`	`155`	`{`
`156`		`- std::cerr << std::format("Error: output file {} open failed - {}", outputFile.string(), std::strerror(errno)) << std::endl;`
	`156`	`+ std::cerr << fmt::format("Error: output file {} open failed - {}", outputFile.string(), std::strerror(errno)) << std::endl;`
`157`	`157`	`return EXIT_FAILURE;`
`158`	`158`	`}`
`159`	`159`
`@@ -169,21 +169,21 @@ int writeGamedataFile(std::list<ClassInfo>& classes, const std::vector<std::file`
`169`	`169`	`auto endPos = line.rfind('#');`
`170`	`170`	`if (endPos == startPos)`
`171`	`171`	`{`
`172`		`- std::cerr << std::format("Error: input file {} contains only one \'#\' at line {}", inputFilePath.string(), lineNumber) << std::endl;`
	`172`	`+ std::cerr << fmt::format("Error: input file {} contains only one \'#\' at line {}", inputFilePath.string(), lineNumber) << std::endl;`
`173`	`173`	`return EINVAL;`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`auto symbol = line.substr(startPos + 1, endPos - startPos - 1);`
`177`	`177`	`if (symbol.empty())`
`178`	`178`	`{`
`179`		`- std::cerr << std::format("Error: symbol from input file {} at line {} is empty somehow", inputFilePath.string(), lineNumber) << std::endl;`
	`179`	`+ std::cerr << fmt::format("Error: symbol from input file {} at line {} is empty somehow", inputFilePath.string(), lineNumber) << std::endl;`
`180`	`180`	`return EINVAL;`
`181`	`181`	`}`
`182`	`182`
`183`	`183`	`auto offset = getOffset(offsets, symbol);`
`184`	`184`	`if (!offset.has_value())`
`185`	`185`	`{`
`186`		`- std::cerr << std::format("Error: failed to get offset of symbol {} from input file {} at line {}", symbol, inputFilePath.string(), lineNumber) << std::endl;`
	`186`	`+ std::cerr << fmt::format("Error: failed to get offset of symbol {} from input file {} at line {}", symbol, inputFilePath.string(), lineNumber) << std::endl;`
`187`	`187`	`return EINVAL;`
`188`	`188`	`}`
`189`	`189`