Update athena

DiscBase: Prevent potential off-by-one case within getPartitonNodeCount()

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "logvisor"]
 	path = logvisor
-	url = https://github.com/AxioDL/logvisor.git
+	url = ../logvisor.git

CMakeLists.txt

@@ -1,18 +1,51 @@
 if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
-cmake_minimum_required(VERSION 3.1.0 FATAL_ERROR) # because of CMAKE_CXX_STANDARD
-project(nod)
-set(CMAKE_CXX_STANDARD 14)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
+  cmake_minimum_required(VERSION 3.10 FATAL_ERROR) # because of c++17
+  project(nod VERSION 0.1)
+  set(CMAKE_CXX_STANDARD 17)
+  set(CMAKE_CXX_STANDARD_REQUIRED ON)
+endif()
+
+include (CMakePackageConfigHelpers)
+
+if (MSVC)
+  # Shaddup MSVC
+  add_definitions(-DUNICODE=1 -D_UNICODE=1 -D__SSE__=1 -D_CRT_SECURE_NO_WARNINGS=1 -DD_SCL_SECURE_NO_WARNINGS=1
+      /IGNORE:4221 /wd4018 /wd4800 /wd4005 /wd4311 /wd4267 /wd4244 /wd4200 /wd4305 /wd4067 /wd4146 ${VS_DEFINES})
 endif()
 
 if (NOT TARGET logvisor)
   add_subdirectory(logvisor)
-    set(LOGVISOR_INCLUDE_DIR logvisor/include)
 endif()
 
-include_directories(include ${LOGVISOR_INCLUDE_DIR})
-file(GLOB NOD_HEADERS include/nod/*.h*)
-
 add_subdirectory(lib)
 add_subdirectory(driver)
-install(DIRECTORY include/nod DESTINATION include/nod)
+
+set(version_config_file "${PROJECT_BINARY_DIR}/nodConfigVersion.cmake")
+set(config_file "${PROJECT_BINARY_DIR}/nodConfig.cmake")
+set(config_install_dir "lib/cmake/nod")
+
+# Install the target config files
+install(
+    EXPORT nodTargets
+    NAMESPACE "nod::"
+    DESTINATION "${config_install_dir}"
+)
+
+# Generate version config file
+write_basic_package_version_file(
+    "${version_config_file}"
+    COMPATIBILITY SameMajorVersion
+)
+
+# Generate config file
+configure_package_config_file(
+    "Config.cmake.in"
+    "${config_file}"
+    INSTALL_DESTINATION "lib/cmake/nod"
+)
+
+# Install the config files
+install(
+    FILES "${config_file}" "${version_config_file}"
+    DESTINATION ${config_install_dir}
+)

Config.cmake.in

@@ -0,0 +1,4 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/nodTargets.cmake")
+check_required_components(nod)

README.md

@@ -41,12 +41,12 @@ auto progFunc = [&](size_t idx, const nod::SystemString& name, size_t bytes)
         lastIdx = idx;
         /* NOD provides I/O wrappers using wchar_t on Windows;
          * _S() conditionally makes string-literals wide */
-        nod::Printf(_S("\n"));
+        fmt::print(_S("\n"));
     }
     if (bytes != -1)
-        nod::Printf(_S("\r%s %" PRISize " B"), name.c_str(), bytes);
+        fmt::print(_S("\r{} {} B"), name, bytes);
     else
-        nod::Printf(_S("\r%s"), name.c_str());
+        fmt::print(_S("\r{}"), name);
     fflush(stdout);
 };
 

driver/main.cpp

@@ -1,16 +1,23 @@
-#include <stdio.h>
-#include <string.h>
-#include "logvisor/logvisor.hpp"
-#include "nod/nod.hpp"
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
 
-static void printHelp()
-{
-    fprintf(stderr, "Usage:\n"
+#include <logvisor/logvisor.hpp>
+
+#include <nod/DiscBase.hpp>
+#include <nod/DiscGCN.hpp>
+#include <nod/DiscWii.hpp>
+#include <nod/nod.hpp>
+
+static void printHelp() {
+  fmt::print(stderr, fmt(
+          "Usage:\n"
           "  nodtool extract [-f] <image-in> [<dir-out>]\n"
           "  nodtool makegcn <fsroot-in> [<image-out>]\n"
           "  nodtool makewii <fsroot-in> [<image-out>]\n"
           "  nodtool mergegcn <fsroot-in> <image-in> [<image-out>]\n"
-                    "  nodtool mergewii <fsroot-in> <image-in> [<image-out>]\n");
+          "  nodtool mergewii <fsroot-in> <image-in> [<image-out>]\n"));
 }
 
 #if NOD_UCS2
@@ -25,12 +32,10 @@ int wmain(int argc, wchar_t* argv[])
 int main(int argc, char* argv[])
 #endif
 {
-    if (argc < 3 ||
-        (!strcasecmp(argv[1], _S("makegcn")) && argc < 3) ||
-        (!strcasecmp(argv[1], _S("makewii")) && argc < 3) ||
-        (!strcasecmp(argv[1], _S("mergegcn")) && argc < 4) ||
-        (!strcasecmp(argv[1], _S("mergewii")) && argc < 4))
-    {
+  if (argc < 3 || (!strcasecmp(argv[1], _SYS_STR("makegcn")) && argc < 3) ||
+      (!strcasecmp(argv[1], _SYS_STR("makewii")) && argc < 3) ||
+      (!strcasecmp(argv[1], _SYS_STR("mergegcn")) && argc < 4) ||
+      (!strcasecmp(argv[1], _SYS_STR("mergewii")) && argc < 4)) {
     printHelp();
     return 1;
   }
@@ -40,16 +45,15 @@ int main(int argc, char* argv[])
   logvisor::RegisterConsoleLogger();
 
   bool verbose = false;
-    nod::ExtractionContext ctx = {true,
-    [&](const std::string& str, float c) {
+  nod::ExtractionContext ctx = {true, [&](std::string_view str, float c) {
                                   if (verbose)
-            fprintf(stderr, "Current node: %s, Extraction %g%% Complete\n", str.c_str(), c * 100.f);
+                                    fmt::print(stderr, fmt("Current node: {}, Extraction {:g}% Complete\n"), str,
+                                               c * 100.f);
                                 }};
   const nod::SystemChar* inDir = nullptr;
-    const nod::SystemChar* outDir = _S(".");
+  const nod::SystemChar* outDir = _SYS_STR(".");
 
-    for (int a=2 ; a<argc ; ++a)
-    {
+  for (int a = 2; a < argc; ++a) {
     if (argv[a][0] == '-' && argv[a][1] == 'f')
       ctx.force = true;
     else if (argv[a][0] == '-' && argv[a][1] == 'v')
@@ -61,18 +65,16 @@ int main(int argc, char* argv[])
       outDir = argv[a];
   }
 
-    auto progFunc = [&](float prog, const nod::SystemString& name, size_t bytes)
-    {
-        nod::Printf(_S("\r                                                                      "));
-        if (bytes != -1)
-            nod::Printf(_S("\r%g%% %s %" PRISize " B"), prog * 100.f, name.c_str(), bytes);
+  auto progFunc = [&](float prog, nod::SystemStringView name, size_t bytes) {
+    fmt::print(fmt(_SYS_STR("\r                                                                      ")));
+    if (bytes != SIZE_MAX)
+      fmt::print(fmt(_SYS_STR("\r{:g}% {} {} B")), prog * 100.f, name, bytes);
     else
-            nod::Printf(_S("\r%g%% %s"), prog * 100.f, name.c_str());
+      fmt::print(fmt(_SYS_STR("\r{:g}% {}")), prog * 100.f, name);
     fflush(stdout);
   };
 
-    if (!strcasecmp(argv[1], _S("extract")))
-    {
+  if (!strcasecmp(argv[1], _SYS_STR("extract"))) {
     bool isWii;
     std::unique_ptr<nod::DiscBase> disc = nod::OpenDiscFromImage(inDir, isWii);
     if (!disc)
@@ -80,186 +82,153 @@ int main(int argc, char* argv[])
 
     nod::Mkdir(outDir, 0755);
 
-        nod::Partition* dataPart = disc->getDataPartition();
+    nod::IPartition* dataPart = disc->getDataPartition();
     if (!dataPart)
       return 1;
 
     if (!dataPart->extractToDirectory(outDir, ctx))
       return 1;
-    }
-    else if (!strcasecmp(argv[1], _S("makegcn")))
-    {
+  } else if (!strcasecmp(argv[1], _SYS_STR("makegcn"))) {
     /* Pre-validate path */
     nod::Sstat theStat;
-        if (nod::Stat(argv[2], &theStat) || !S_ISDIR(theStat.st_mode))
-        {
-            nod::LogModule.report(logvisor::Error, _S("unable to stat %s as directory"), argv[2]);
+    if (nod::Stat(argv[2], &theStat) || !S_ISDIR(theStat.st_mode)) {
+      nod::LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {} as directory")), argv[2]);
       return 1;
     }
 
-        if (nod::DiscBuilderGCN::CalculateTotalSizeRequired(argv[2]) == -1)
+    if (nod::DiscBuilderGCN::CalculateTotalSizeRequired(argv[2]) == UINT64_MAX)
       return 1;
 
     nod::EBuildResult ret;
 
-        if (argc < 4)
-        {
+    if (argc < 4) {
       nod::SystemString outPath(argv[2]);
-            outPath.append(_S(".iso"));
-            nod::DiscBuilderGCN b(outPath.c_str(), progFunc);
+      outPath.append(_SYS_STR(".iso"));
+      nod::DiscBuilderGCN b(outPath, progFunc);
       ret = b.buildFromDirectory(argv[2]);
-        }
-        else
-        {
+    } else {
       nod::DiscBuilderGCN b(argv[3], progFunc);
       ret = b.buildFromDirectory(argv[2]);
     }
 
-        printf("\n");
+    fmt::print(fmt("\n"));
     if (ret != nod::EBuildResult::Success)
       return 1;
-    }
-    else if (!strcasecmp(argv[1], _S("makewii")))
-    {
+  } else if (!strcasecmp(argv[1], _SYS_STR("makewii"))) {
     /* Pre-validate path */
     nod::Sstat theStat;
-        if (nod::Stat(argv[2], &theStat) || !S_ISDIR(theStat.st_mode))
-        {
-            nod::LogModule.report(logvisor::Error, _S("unable to stat %s as directory"), argv[4]);
+    if (nod::Stat(argv[2], &theStat) || !S_ISDIR(theStat.st_mode)) {
+      nod::LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {} as directory")), argv[4]);
       return 1;
     }
 
     bool dual = false;
-        if (nod::DiscBuilderWii::CalculateTotalSizeRequired(argv[2], dual) == -1)
+    if (nod::DiscBuilderWii::CalculateTotalSizeRequired(argv[2], dual) == UINT64_MAX)
       return 1;
 
     nod::EBuildResult ret;
 
-        if (argc < 4)
-        {
+    if (argc < 4) {
       nod::SystemString outPath(argv[2]);
-            outPath.append(_S(".iso"));
+      outPath.append(_SYS_STR(".iso"));
       nod::DiscBuilderWii b(outPath.c_str(), dual, progFunc);
       ret = b.buildFromDirectory(argv[2]);
-        }
-        else
-        {
+    } else {
       nod::DiscBuilderWii b(argv[3], dual, progFunc);
       ret = b.buildFromDirectory(argv[2]);
     }
 
-        printf("\n");
+    fmt::print(fmt("\n"));
     if (ret != nod::EBuildResult::Success)
       return 1;
-    }
-    else if (!strcasecmp(argv[1], _S("mergegcn")))
-    {
+  } else if (!strcasecmp(argv[1], _SYS_STR("mergegcn"))) {
     /* Pre-validate paths */
     nod::Sstat theStat;
-        if (nod::Stat(argv[2], &theStat) || !S_ISDIR(theStat.st_mode))
-        {
-            nod::LogModule.report(logvisor::Error, _S("unable to stat %s as directory"), argv[2]);
+    if (nod::Stat(argv[2], &theStat) || !S_ISDIR(theStat.st_mode)) {
+      nod::LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {} as directory")), argv[2]);
       return 1;
     }
-        if (nod::Stat(argv[3], &theStat) || !S_ISREG(theStat.st_mode))
-        {
-            nod::LogModule.report(logvisor::Error, _S("unable to stat %s as file"), argv[3]);
+    if (nod::Stat(argv[3], &theStat) || !S_ISREG(theStat.st_mode)) {
+      nod::LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {} as file")), argv[3]);
       return 1;
     }
 
     bool isWii;
     std::unique_ptr<nod::DiscBase> disc = nod::OpenDiscFromImage(argv[3], isWii);
-        if (!disc)
-        {
-            nod::LogModule.report(logvisor::Error, _S("unable to open image %s"), argv[3]);
+    if (!disc) {
+      nod::LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to open image {}")), argv[3]);
       return 1;
     }
-        if (isWii)
-        {
-            nod::LogModule.report(logvisor::Error, _S("Wii images should be merged with 'mergewii'"));
+    if (isWii) {
+      nod::LogModule.report(logvisor::Error, fmt(_SYS_STR("Wii images should be merged with 'mergewii'")));
       return 1;
     }
 
-        if (nod::DiscMergerGCN::CalculateTotalSizeRequired(static_cast<nod::DiscGCN&>(*disc), argv[2]) == -1)
+    if (nod::DiscMergerGCN::CalculateTotalSizeRequired(static_cast<nod::DiscGCN&>(*disc), argv[2]) == UINT64_MAX)
       return 1;
 
     nod::EBuildResult ret;
 
-        if (argc < 5)
-        {
+    if (argc < 5) {
       nod::SystemString outPath(argv[2]);
-            outPath.append(_S(".iso"));
+      outPath.append(_SYS_STR(".iso"));
       nod::DiscMergerGCN b(outPath.c_str(), static_cast<nod::DiscGCN&>(*disc), progFunc);
       ret = b.mergeFromDirectory(argv[2]);
-        }
-        else
-        {
+    } else {
       nod::DiscMergerGCN b(argv[4], static_cast<nod::DiscGCN&>(*disc), progFunc);
       ret = b.mergeFromDirectory(argv[2]);
     }
 
-        printf("\n");
+    fmt::print(fmt("\n"));
     if (ret != nod::EBuildResult::Success)
       return 1;
-    }
-    else if (!strcasecmp(argv[1], _S("mergewii")))
-    {
+  } else if (!strcasecmp(argv[1], _SYS_STR("mergewii"))) {
     /* Pre-validate paths */
     nod::Sstat theStat;
-        if (nod::Stat(argv[2], &theStat) || !S_ISDIR(theStat.st_mode))
-        {
-            nod::LogModule.report(logvisor::Error, _S("unable to stat %s as directory"), argv[2]);
+    if (nod::Stat(argv[2], &theStat) || !S_ISDIR(theStat.st_mode)) {
+      nod::LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {} as directory")), argv[2]);
       return 1;
     }
-        if (nod::Stat(argv[3], &theStat) || !S_ISREG(theStat.st_mode))
-        {
-            nod::LogModule.report(logvisor::Error, _S("unable to stat %s as file"), argv[3]);
+    if (nod::Stat(argv[3], &theStat) || !S_ISREG(theStat.st_mode)) {
+      nod::LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {} as file")), argv[3]);
       return 1;
     }
 
     bool isWii;
     std::unique_ptr<nod::DiscBase> disc = nod::OpenDiscFromImage(argv[3], isWii);
-        if (!disc)
-        {
-            nod::LogModule.report(logvisor::Error, _S("unable to open image %s"), argv[3]);
+    if (!disc) {
+      nod::LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to open image {}")), argv[3]);
       return 1;
     }
-        if (!isWii)
-        {
-            nod::LogModule.report(logvisor::Error, _S("GameCube images should be merged with 'mergegcn'"));
+    if (!isWii) {
+      nod::LogModule.report(logvisor::Error, fmt(_SYS_STR("GameCube images should be merged with 'mergegcn'")));
       return 1;
     }
 
     bool dual = false;
-        if (nod::DiscMergerWii::CalculateTotalSizeRequired(static_cast<nod::DiscWii&>(*disc), argv[2], dual) == -1)
+    if (nod::DiscMergerWii::CalculateTotalSizeRequired(static_cast<nod::DiscWii&>(*disc), argv[2], dual) == UINT64_MAX)
       return 1;
 
     nod::EBuildResult ret;
 
-        if (argc < 5)
-        {
+    if (argc < 5) {
       nod::SystemString outPath(argv[2]);
-            outPath.append(_S(".iso"));
+      outPath.append(_SYS_STR(".iso"));
       nod::DiscMergerWii b(outPath.c_str(), static_cast<nod::DiscWii&>(*disc), dual, progFunc);
       ret = b.mergeFromDirectory(argv[2]);
-        }
-        else
-        {
+    } else {
       nod::DiscMergerWii b(argv[4], static_cast<nod::DiscWii&>(*disc), dual, progFunc);
       ret = b.mergeFromDirectory(argv[2]);
     }
 
-        printf("\n");
+    fmt::print(fmt("\n"));
     if (ret != nod::EBuildResult::Success)
       return 1;
-    }
-    else
-    {
+  } else {
     printHelp();
     return 1;
   }
 
-    nod::LogModule.report(logvisor::Info, _S("Success!"));
+  nod::LogModule.report(logvisor::Info, fmt(_SYS_STR("Success!")));
   return 0;
 }
-

include/nod/DirectoryEnumerator.hpp

@@ -1,73 +1,54 @@
-#ifndef __NOD_DIRECTORY_ENUMERATOR__
-#define __NOD_DIRECTORY_ENUMERATOR__
+#pragma once
 
-#include "Util.hpp"
+#include <algorithm>
+#include <cctype>
+#include <cstddef>
+#include <vector>
 
-namespace nod
-{
+#include "nod/Util.hpp"
 
-struct CaseInsensitiveCompare
-{
-    bool operator()(const std::string& lhs, const std::string& rhs) const
-    {
-#if _WIN32
-        if (_stricmp(lhs.c_str(), rhs.c_str()) < 0)
-#else
-        if (strcasecmp(lhs.c_str(), rhs.c_str()) < 0)
-#endif
-            return true;
-        return false;
+namespace nod {
+
+struct CaseInsensitiveCompare {
+  bool operator()(std::string_view lhs, std::string_view rhs) const {
+    return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), [](char lhs, char rhs) {
+      return std::tolower(static_cast<unsigned char>(lhs)) < std::tolower(static_cast<unsigned char>(rhs));
+    });
   }
 
 #if _WIN32
-    bool operator()(const std::wstring& lhs, const std::wstring& rhs) const
-    {
-        if (_wcsicmp(lhs.c_str(), rhs.c_str()) < 0)
-            return true;
-        return false;
+  bool operator()(std::wstring_view lhs, std::wstring_view rhs) const {
+    return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), [](wchar_t lhs, wchar_t rhs) {
+      return std::towlower(lhs) < std::towlower(rhs);
+    });
   }
 #endif
 };
 
-class DirectoryEnumerator
-{
+class DirectoryEnumerator {
 public:
-    enum class Mode
-    {
-        Native,
-        DirsSorted,
-        FilesSorted,
-        DirsThenFilesSorted
-    };
-    struct Entry
-    {
+  enum class Mode { Native, DirsSorted, FilesSorted, DirsThenFilesSorted };
+  struct Entry {
     SystemString m_path;
     SystemString m_name;
     size_t m_fileSz;
     bool m_isDir;
 
-    private:
-        friend class DirectoryEnumerator;
-        Entry(SystemString&& path, const SystemChar* name, size_t sz, bool isDir)
-        : m_path(std::move(path)), m_name(name), m_fileSz(sz), m_isDir(isDir) {}
+    Entry(const SystemString& path, const SystemChar* name, size_t sz, bool isDir)
+    : m_path(path), m_name(name), m_fileSz(sz), m_isDir(isDir) {}
   };
 
 private:
   std::vector<Entry> m_entries;
 
 public:
-    DirectoryEnumerator(const SystemString& path, Mode mode=Mode::DirsThenFilesSorted,
-                        bool sizeSort=false, bool reverse=false, bool noHidden=false)
-    : DirectoryEnumerator(path.c_str(), mode, sizeSort, reverse, noHidden) {}
-    DirectoryEnumerator(const SystemChar* path, Mode mode=Mode::DirsThenFilesSorted,
-                        bool sizeSort=false, bool reverse=false, bool noHidden=false);
+  DirectoryEnumerator(SystemStringView path, Mode mode = Mode::DirsThenFilesSorted, bool sizeSort = false,
+                      bool reverse = false, bool noHidden = false);
 
-    operator bool() const {return m_entries.size() != 0;}
-    size_t size() const {return m_entries.size();}
-    std::vector<Entry>::const_iterator begin() const {return m_entries.cbegin();}
-    std::vector<Entry>::const_iterator end() const {return m_entries.cend();}
+  operator bool() const { return m_entries.size() != 0; }
+  size_t size() const { return m_entries.size(); }
+  std::vector<Entry>::const_iterator begin() const { return m_entries.cbegin(); }
+  std::vector<Entry>::const_iterator end() const { return m_entries.cend(); }
 };
 
-}
-
-#endif // __NOD_DIRECTORY_ENUMERATOR__
+} // namespace nod

include/nod/DiscBase.hpp

@@ -1,65 +1,52 @@
-#ifndef __NOD_DISC_BASE__
-#define __NOD_DISC_BASE__
+#pragma once
 
-#include <vector>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <functional>
 #include <memory>
 #include <string>
 #include <unordered_map>
-#include <stdio.h>
-#include <stdint.h>
-#include <functional>
-#include "Util.hpp"
-#include "IDiscIO.hpp"
-#include "IFileIO.hpp"
+#include <vector>
 
-namespace nod
-{
+#include "nod/IDiscIO.hpp"
+#include "nod/IFileIO.hpp"
+#include "nod/Util.hpp"
 
-using FProgress = std::function<void(float totalProg, const SystemString& fileName, size_t fileBytesXfered)>;
+namespace nod {
 
-enum class EBuildResult
-{
-    Success,
-    Failed,
-    DiskFull
-};
+using FProgress = std::function<void(float totalProg, SystemStringView fileName, size_t fileBytesXfered)>;
 
-enum class PartitionKind : uint32_t
-{
-    Data,
-    Update,
-    Channel
-};
+enum class EBuildResult { Success, Failed, DiskFull };
+
+enum class PartitionKind : uint32_t { Data, Update, Channel };
 const SystemChar* getKindString(PartitionKind kind);
 
-class FSTNode
-{
+class FSTNode {
   uint32_t typeAndNameOffset;
   uint32_t offset;
   uint32_t length;
+
 public:
-    FSTNode(bool isDir, uint32_t nameOff, uint32_t off, uint32_t len)
-    {
+  FSTNode(bool isDir, uint32_t nameOff, uint32_t off, uint32_t len) {
     typeAndNameOffset = nameOff & 0xffffff;
     typeAndNameOffset |= isDir << 24;
     typeAndNameOffset = SBig(typeAndNameOffset);
     offset = SBig(off);
     length = SBig(len);
   }
-    inline bool isDir() const {return ((SBig(typeAndNameOffset) >> 24) != 0);}
-    inline uint32_t getNameOffset() const {return SBig(typeAndNameOffset) & 0xffffff;}
-    inline uint32_t getOffset() const {return SBig(offset);}
-    inline uint32_t getLength() const {return SBig(length);}
-    void incrementLength()
-    {
+  bool isDir() const { return ((SBig(typeAndNameOffset) >> 24) != 0); }
+  uint32_t getNameOffset() const { return SBig(typeAndNameOffset) & 0xffffff; }
+  uint32_t getOffset() const { return SBig(offset); }
+  uint32_t getLength() const { return SBig(length); }
+  void incrementLength() {
     uint32_t orig = SBig(length);
     ++orig;
     length = SBig(orig);
   }
 };
 
-struct Header
-{
+struct Header {
   char m_gameID[6];
   char m_discNum;
   char m_discVersion;
@@ -85,19 +72,16 @@ struct Header
   uint8_t padding1[4];
 
   Header() = default;
-    Header(IDiscIO& dio, bool& err)
-    {
+  Header(IDiscIO& dio, bool& err) {
     auto rs = dio.beginReadStream();
-        if (!rs)
-        {
+    if (!rs) {
       err = true;
       return;
     }
     read(*rs);
   }
 
-    void read(IReadStream& s)
-    {
+  void read(IReadStream& s) {
     memset(this, 0, sizeof(*this));
     s.read(this, sizeof(*this));
     m_wiiMagic = SBig(m_wiiMagic);
@@ -113,8 +97,7 @@ struct Header
     m_userSz = SBig(m_userSz);
   }
 
-    void write(IWriteStream& ws) const
-    {
+  void write(IWriteStream& ws) const {
     Header hs(*this);
     hs.m_wiiMagic = SBig(hs.m_wiiMagic);
     hs.m_gcnMagic = SBig(hs.m_gcnMagic);
@@ -132,8 +115,7 @@ struct Header
 };
 
 /* Currently only kept for dolphin compatibility */
-struct BI2Header
-{
+struct BI2Header {
   int32_t m_debugMonitorSize;
   int32_t m_simMemSize;
   uint32_t m_argOffset;
@@ -148,8 +130,7 @@ struct BI2Header
   uint32_t m_unk4;
   uint8_t padding2[0x1FD0];
 
-    void read(IReadStream& rs)
-    {
+  void read(IReadStream& rs) {
     memset(this, 0, sizeof(*this));
     rs.read(this, sizeof(*this));
     m_debugMonitorSize = SBig(m_debugMonitorSize);
@@ -166,8 +147,7 @@ struct BI2Header
     m_unk4 = SBig(m_unk4);
   }
 
-    void write(IWriteStream& ws) const
-    {
+  void write(IWriteStream& ws) const {
     BI2Header h = *this;
     h.m_debugMonitorSize = SBig(h.m_debugMonitorSize);
     h.m_simMemSize = SBig(h.m_simMemSize);
@@ -186,37 +166,14 @@ struct BI2Header
 };
 
 struct ExtractionContext;
-class DiscBase
-{
+class IPartition;
+class DiscBase;
+
+class Node {
 public:
-    virtual ~DiscBase() = default;
+  enum class Kind { File, Directory };
 
-    class IPartition
-    {
-    public:
-        virtual ~IPartition() = default;
-        struct DOLHeader
-        {
-            uint32_t textOff[7];
-            uint32_t dataOff[11];
-            uint32_t textStarts[7];
-            uint32_t dataStarts[11];
-            uint32_t textSizes[7];
-            uint32_t dataSizes[11];
-            uint32_t bssStart;
-            uint32_t bssSize;
-            uint32_t entryPoint;
-        };
-
-        class Node
-        {
-        public:
-            enum class Kind
-            {
-                File,
-                Directory
-            };
-        private:
+private:
   friend class IPartition;
   const IPartition& m_parent;
   Kind m_kind;
@@ -228,68 +185,48 @@ public:
   std::vector<Node>::iterator m_childrenBegin;
   std::vector<Node>::iterator m_childrenEnd;
 
-        public:
-            Node(const IPartition& parent, const FSTNode& node, const char* name)
-            : m_parent(parent),
-              m_kind(node.isDir() ? Kind::Directory : Kind::File),
-              m_discOffset(parent.normalizeOffset(node.getOffset())),
-              m_discLength(node.getLength()),
-              m_name(name) {}
-            inline Kind getKind() const {return m_kind;}
-            inline const std::string& getName() const {return m_name;}
-            inline uint64_t size() const {return m_discLength;}
-            std::unique_ptr<IPartReadStream> beginReadStream(uint64_t offset=0) const
-            {
-                if (m_kind != Kind::File)
-                {
-                    LogModule.report(logvisor::Error, "unable to stream a non-file %s", m_name.c_str());
-                    return std::unique_ptr<IPartReadStream>();
-                }
-                return m_parent.beginReadStream(m_discOffset + offset);
-            }
-            std::unique_ptr<uint8_t[]> getBuf() const
-            {
-                if (m_kind != Kind::File)
-                {
-                    LogModule.report(logvisor::Error, "unable to buffer a non-file %s", m_name.c_str());
-                    return std::unique_ptr<uint8_t[]>();
-                }
-                uint8_t* buf = new uint8_t[m_discLength];
-                beginReadStream()->read(buf, m_discLength);
-                return std::unique_ptr<uint8_t[]>(buf);
-            }
-            inline std::vector<Node>::iterator rawBegin() const {return m_childrenBegin;}
-            inline std::vector<Node>::iterator rawEnd() const {return m_childrenEnd;}
+public:
+  Node(const IPartition& parent, const FSTNode& node, std::string_view name);
+  Kind getKind() const { return m_kind; }
+  std::string_view getName() const { return m_name; }
+  uint64_t size() const { return m_discLength; }
+  std::unique_ptr<IPartReadStream> beginReadStream(uint64_t offset = 0) const;
+  std::unique_ptr<uint8_t[]> getBuf() const;
+  std::vector<Node>::iterator rawBegin() const { return m_childrenBegin; }
+  std::vector<Node>::iterator rawEnd() const { return m_childrenEnd; }
 
-            class DirectoryIterator : std::iterator<std::forward_iterator_tag, Node>
-            {
+  class DirectoryIterator {
     friend class Node;
     std::vector<Node>::iterator m_it;
-                DirectoryIterator(const std::vector<Node>::iterator& it)
-                : m_it(it) {}
+    DirectoryIterator(const std::vector<Node>::iterator& it) : m_it(it) {}
+
   public:
-                inline bool operator!=(const DirectoryIterator& other) {return m_it != other.m_it;}
-                inline bool operator==(const DirectoryIterator& other) {return m_it == other.m_it;}
-                inline DirectoryIterator& operator++()
-                {
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = Node;
+    using difference_type = std::ptrdiff_t;
+    using pointer = Node*;
+    using reference = Node&;
+
+    bool operator==(const DirectoryIterator& other) const { return m_it == other.m_it; }
+    bool operator!=(const DirectoryIterator& other) const { return !operator==(other); }
+    DirectoryIterator& operator++() {
       if (m_it->m_kind == Kind::Directory)
         m_it = m_it->rawEnd();
       else
         ++m_it;
       return *this;
     }
-                inline Node& operator*() {return *m_it;}
-                inline Node* operator->() {return &*m_it;}
+    Node& operator*() { return *m_it; }
+    const Node& operator*() const { return *m_it; }
+    Node* operator->() { return &*m_it; }
+    const Node* operator->() const { return &*m_it; }
   };
-            inline DirectoryIterator begin() const {return DirectoryIterator(m_childrenBegin);}
-            inline DirectoryIterator end() const {return DirectoryIterator(m_childrenEnd);}
-            inline DirectoryIterator find(const std::string& name) const
-            {
-                if (m_kind == Kind::Directory)
-                {
-                    DirectoryIterator it=begin();
-                    for (; it != end() ; ++it)
-                    {
+  DirectoryIterator begin() const { return DirectoryIterator(m_childrenBegin); }
+  DirectoryIterator end() const { return DirectoryIterator(m_childrenEnd); }
+  DirectoryIterator find(std::string_view name) const {
+    if (m_kind == Kind::Directory) {
+      DirectoryIterator it = begin();
+      for (; it != end(); ++it) {
         if (!it->getName().compare(name))
           return it;
       }
@@ -298,9 +235,25 @@ public:
     return end();
   }
 
-            bool extractToDirectory(const SystemString& basePath, const ExtractionContext& ctx) const;
+  bool extractToDirectory(SystemStringView basePath, const ExtractionContext& ctx) const;
+};
+
+class IPartition {
+public:
+  virtual ~IPartition() = default;
+  struct DOLHeader {
+    uint32_t textOff[7];
+    uint32_t dataOff[11];
+    uint32_t textStarts[7];
+    uint32_t dataStarts[11];
+    uint32_t textSizes[7];
+    uint32_t dataSizes[11];
+    uint32_t bssStart;
+    uint32_t bssSize;
+    uint32_t entryPoint;
   };
-    protected:
+
+protected:
   Header m_header;
   BI2Header m_bi2Header;
   uint64_t m_dolOff;
@@ -313,7 +266,6 @@ public:
   std::vector<FSTNode> m_buildNodes;
   std::vector<std::string> m_buildNames;
   size_t m_buildNameOff = 0;
-        void recursiveBuildNodes(const SystemChar* dirIn, std::function<void(void)> incParents);
 
   uint64_t m_dolSz;
   void parseDOL(IPartReadStream& s);
@@ -322,11 +274,11 @@ public:
   PartitionKind m_kind;
   uint64_t m_offset;
   bool m_isWii;
-    public:
+
+public:
   mutable size_t m_curNodeIdx = 0;
   float getProgressFactor() const { return getNodeCount() ? m_curNodeIdx / float(getNodeCount()) : 0.f; }
-        float getProgressFactorMidFile(size_t curByte, size_t totalBytes) const
-        {
+  float getProgressFactorMidFile(size_t curByte, size_t totalBytes) const {
     if (!getNodeCount())
       return 0.f;
 
@@ -338,131 +290,127 @@ public:
 
   IPartition(const DiscBase& parent, PartitionKind kind, bool isWii, uint64_t offset)
   : m_parent(parent), m_kind(kind), m_offset(offset), m_isWii(isWii) {}
-        virtual uint64_t normalizeOffset(uint64_t anOffset) const {return anOffset;}
-        inline PartitionKind getKind() const {return m_kind;}
-        inline bool isWii() const {return m_isWii;}
-        inline uint64_t getDiscOffset() const {return m_offset;}
-        virtual std::unique_ptr<IPartReadStream> beginReadStream(uint64_t offset=0) const=0;
-        inline std::unique_ptr<IPartReadStream> beginDOLReadStream(uint64_t offset=0) const
-        {return beginReadStream(m_dolOff + offset);}
-        inline std::unique_ptr<IPartReadStream> beginFSTReadStream(uint64_t offset=0) const
-        {return beginReadStream(m_fstOff + offset);}
-        inline std::unique_ptr<IPartReadStream> beginApploaderReadStream(uint64_t offset=0) const
-        {return beginReadStream(0x2440 + offset);}
-        inline const Node& getFSTRoot() const {return m_nodes[0];}
-        inline Node& getFSTRoot() {return m_nodes[0];}
-        bool extractToDirectory(const SystemString& path, const ExtractionContext& ctx);
+  virtual uint64_t normalizeOffset(uint64_t anOffset) const { return anOffset; }
+  PartitionKind getKind() const { return m_kind; }
+  bool isWii() const { return m_isWii; }
+  uint64_t getDiscOffset() const { return m_offset; }
+  virtual std::unique_ptr<IPartReadStream> beginReadStream(uint64_t offset = 0) const = 0;
+  std::unique_ptr<IPartReadStream> beginDOLReadStream(uint64_t offset = 0) const {
+    return beginReadStream(m_dolOff + offset);
+  }
+  std::unique_ptr<IPartReadStream> beginFSTReadStream(uint64_t offset = 0) const {
+    return beginReadStream(m_fstOff + offset);
+  }
+  std::unique_ptr<IPartReadStream> beginApploaderReadStream(uint64_t offset = 0) const {
+    return beginReadStream(0x2440 + offset);
+  }
+  const Node& getFSTRoot() const { return m_nodes[0]; }
+  Node& getFSTRoot() { return m_nodes[0]; }
+  bool extractToDirectory(SystemStringView path, const ExtractionContext& ctx);
 
-        inline uint64_t getDOLSize() const {return m_dolSz;}
-        inline std::unique_ptr<uint8_t[]> getDOLBuf() const
-        {
+  uint64_t getDOLSize() const { return m_dolSz; }
+  std::unique_ptr<uint8_t[]> getDOLBuf() const {
     std::unique_ptr<uint8_t[]> buf(new uint8_t[m_dolSz]);
     beginDOLReadStream()->read(buf.get(), m_dolSz);
     return buf;
   }
 
-        inline uint64_t getFSTSize() const {return m_fstSz;}
-        inline std::unique_ptr<uint8_t[]> getFSTBuf() const
-        {
+  uint64_t getFSTSize() const { return m_fstSz; }
+  std::unique_ptr<uint8_t[]> getFSTBuf() const {
     std::unique_ptr<uint8_t[]> buf(new uint8_t[m_fstSz]);
     beginFSTReadStream()->read(buf.get(), m_fstSz);
     return buf;
   }
 
-        inline uint64_t getApploaderSize() const {return m_apploaderSz;}
-        inline std::unique_ptr<uint8_t[]> getApploaderBuf() const
-        {
+  uint64_t getApploaderSize() const { return m_apploaderSz; }
+  std::unique_ptr<uint8_t[]> getApploaderBuf() const {
     std::unique_ptr<uint8_t[]> buf(new uint8_t[m_apploaderSz]);
     beginApploaderReadStream()->read(buf.get(), m_apploaderSz);
     return buf;
   }
 
-        inline size_t getNodeCount() const { return m_nodes.size(); }
-        inline const Header& getHeader() const { return m_header; }
-        inline const BI2Header& getBI2() const { return m_bi2Header; }
-        virtual bool extractCryptoFiles(const SystemString& path, const ExtractionContext& ctx) const { return true; }
-    };
+  size_t getNodeCount() const { return m_nodes.size(); }
+  const Header& getHeader() const { return m_header; }
+  const BI2Header& getBI2() const { return m_bi2Header; }
+  virtual bool extractCryptoFiles(SystemStringView path, const ExtractionContext& ctx) const { return true; }
+  bool extractSysFiles(SystemStringView path, const ExtractionContext& ctx) const;
+};
+
+class DiscBase {
+public:
+  virtual ~DiscBase() = default;
 
 protected:
   std::unique_ptr<IDiscIO> m_discIO;
   Header m_header;
   std::vector<std::unique_ptr<IPartition>> m_partitions;
-public:
-    DiscBase(std::unique_ptr<IDiscIO>&& dio, bool& err)
-    : m_discIO(std::move(dio)), m_header(*m_discIO, err) {}
 
-    inline const Header& getHeader() const {return m_header;}
-    inline const IDiscIO& getDiscIO() const {return *m_discIO;}
-    inline size_t getPartitonNodeCount(size_t partition = 0) const
-    {
-        if (partition > m_partitions.size())
+public:
+  DiscBase(std::unique_ptr<IDiscIO>&& dio, bool& err) : m_discIO(std::move(dio)), m_header(*m_discIO, err) {}
+
+  const Header& getHeader() const { return m_header; }
+  const IDiscIO& getDiscIO() const { return *m_discIO; }
+  size_t getPartitionNodeCount(size_t partition = 0) const {
+    if (partition >= m_partitions.size()) {
       return -1;
+    }
     return m_partitions[partition]->getNodeCount();
   }
 
-    inline IPartition* getDataPartition()
-    {
+  IPartition* getDataPartition() {
     for (const std::unique_ptr<IPartition>& part : m_partitions)
       if (part->getKind() == PartitionKind::Data)
         return part.get();
     return nullptr;
   }
 
-    inline IPartition* getUpdatePartition()
-    {
+  IPartition* getUpdatePartition() {
     for (const std::unique_ptr<IPartition>& part : m_partitions)
       if (part->getKind() == PartitionKind::Update)
         return part.get();
     return nullptr;
   }
 
-    inline void extractToDirectory(const SystemString& path, const ExtractionContext& ctx)
-    {
+  void extractToDirectory(SystemStringView path, const ExtractionContext& ctx) {
     for (std::unique_ptr<IPartition>& part : m_partitions)
       part->extractToDirectory(path, ctx);
   }
 
-    virtual bool extractDiscHeaderFiles(const SystemString& path, const ExtractionContext& ctx) const=0;
+  virtual bool extractDiscHeaderFiles(SystemStringView path, const ExtractionContext& ctx) const = 0;
 };
 
-class DiscBuilderBase
-{
+class DiscBuilderBase {
   friend class DiscMergerWii;
+
 public:
-    class PartitionBuilderBase
-    {
+  class PartitionBuilderBase {
   public:
     virtual ~PartitionBuilderBase() = default;
+
   protected:
-        std::unordered_map<SystemString, std::pair<uint64_t,uint64_t>> m_fileOffsetsSizes;
+    std::unordered_map<SystemString, std::pair<uint64_t, uint64_t>> m_fileOffsetsSizes;
     std::vector<FSTNode> m_buildNodes;
     std::vector<std::string> m_buildNames;
     size_t m_buildNameOff = 0;
-        virtual uint64_t userAllocate(uint64_t reqSz, IPartWriteStream& ws)=0;
-        virtual uint32_t packOffset(uint64_t offset) const=0;
+    virtual uint64_t userAllocate(uint64_t reqSz, IPartWriteStream& ws) = 0;
+    virtual uint32_t packOffset(uint64_t offset) const = 0;
 
-        void recursiveBuildNodesPre(const SystemChar* dirIn);
-        bool recursiveBuildNodes(IPartWriteStream& ws, bool system, const SystemChar* dirIn);
+    void recursiveBuildNodesPre(SystemStringView dirIn);
+    bool recursiveBuildNodes(IPartWriteStream& ws, bool system, SystemStringView dirIn);
 
-        bool recursiveBuildFST(const SystemChar* dirIn,
-                               std::function<void(void)> incParents);
+    bool recursiveBuildFST(SystemStringView dirIn, std::function<void(void)> incParents, size_t parentDirIdx);
 
-        void recursiveMergeNodesPre(const DiscBase::IPartition::Node* nodeIn, const SystemChar* dirIn);
-        bool recursiveMergeNodes(IPartWriteStream& ws, bool system,
-                                 const DiscBase::IPartition::Node* nodeIn, const SystemChar* dirIn,
-                                 const SystemString& keyPath);
-        bool recursiveMergeFST(const DiscBase::IPartition::Node* nodeIn,
-                               const SystemChar* dirIn, std::function<void(void)> incParents,
-                               const SystemString& keyPath);
+    void recursiveMergeNodesPre(const Node* nodeIn, SystemStringView dirIn);
+    bool recursiveMergeNodes(IPartWriteStream& ws, bool system, const Node* nodeIn, SystemStringView dirIn,
+                             SystemStringView keyPath);
+    bool recursiveMergeFST(const Node* nodeIn, SystemStringView dirIn, std::function<void(void)> incParents,
+                           SystemStringView keyPath);
 
-        static bool RecursiveCalculateTotalSize(uint64_t& totalSz,
-                                                const DiscBase::IPartition::Node* nodeIn,
-                                                const SystemChar* dirIn);
+    static bool RecursiveCalculateTotalSize(uint64_t& totalSz, const Node* nodeIn, SystemStringView dirIn);
 
-        void addBuildName(const SystemString& str)
-        {
-            SystemUTF8View utf8View(str);
-            m_buildNames.push_back(utf8View.utf8_str());
+    void addBuildName(SystemStringView str) {
+      SystemUTF8Conv utf8View(str);
+      m_buildNames.emplace_back(utf8View.utf8_str());
       m_buildNameOff += str.size() + 1;
     }
 
@@ -471,36 +419,31 @@ public:
     uint64_t m_dolOffset = 0;
     uint64_t m_dolSize = 0;
     bool m_isWii;
+
   public:
     PartitionBuilderBase(DiscBuilderBase& parent, PartitionKind kind, bool isWii)
-        : m_parent(parent), m_kind(kind), m_isWii(isWii)
-        {}
-        virtual std::unique_ptr<IPartWriteStream> beginWriteStream(uint64_t offset)=0;
-        bool buildFromDirectory(IPartWriteStream& ws,
-                                const SystemChar* dirIn);
-        static uint64_t CalculateTotalSizeBuild(const SystemChar* dirIn,
-                                                PartitionKind kind, bool isWii);
-        bool mergeFromDirectory(IPartWriteStream& ws,
-                                const DiscBase::IPartition* partIn,
-                                const SystemChar* dirIn);
-        static uint64_t CalculateTotalSizeMerge(const DiscBase::IPartition* partIn,
-                                                const SystemChar* dirIn);
+    : m_parent(parent), m_kind(kind), m_isWii(isWii) {}
+    virtual std::unique_ptr<IPartWriteStream> beginWriteStream(uint64_t offset) = 0;
+    bool buildFromDirectory(IPartWriteStream& ws, SystemStringView dirIn);
+    static uint64_t CalculateTotalSizeBuild(SystemStringView dirIn, PartitionKind kind, bool isWii);
+    bool mergeFromDirectory(IPartWriteStream& ws, const IPartition* partIn, SystemStringView dirIn);
+    static uint64_t CalculateTotalSizeMerge(const IPartition* partIn, SystemStringView dirIn);
   };
+
 protected:
   SystemString m_outPath;
   std::unique_ptr<IFileIO> m_fileIO;
   std::vector<std::unique_ptr<PartitionBuilderBase>> m_partitions;
   int64_t m_discCapacity;
+
 public:
   FProgress m_progressCB;
   size_t m_progressIdx = 0;
   size_t m_progressTotal = 0;
-    float getProgressFactor() const
-    {
+  float getProgressFactor() const {
     return m_progressTotal ? std::min(1.f, m_progressIdx / float(m_progressTotal)) : 0.f;
   }
-    float getProgressFactorMidFile(size_t curByte, size_t totalBytes) const
-    {
+  float getProgressFactorMidFile(size_t curByte, size_t totalBytes) const {
     if (!m_progressTotal)
       return 0.f;
 
@@ -511,19 +454,15 @@ public:
   }
 
   virtual ~DiscBuilderBase() = default;
-    DiscBuilderBase(const SystemChar* outPath,
-                    int64_t discCapacity, FProgress progressCB)
-    : m_outPath(outPath), m_fileIO(NewFileIO(outPath, discCapacity)),
-      m_discCapacity(discCapacity), m_progressCB(progressCB) {}
+  DiscBuilderBase(SystemStringView outPath, int64_t discCapacity, FProgress progressCB)
+  : m_outPath(outPath)
+  , m_fileIO(NewFileIO(outPath, discCapacity))
+  , m_discCapacity(discCapacity)
+  , m_progressCB(std::move(progressCB)) {}
   DiscBuilderBase(DiscBuilderBase&&) = default;
   DiscBuilderBase& operator=(DiscBuilderBase&&) = default;
 
   IFileIO& getFileIO() { return *m_fileIO; }
 };
 
-using Partition = DiscBase::IPartition;
-using Node = Partition::Node;
-
-}
-
-#endif // __NOD_DISC_BASE__
+} // namespace nod

include/nod/DiscGCN.hpp

@@ -1,41 +1,36 @@
-#ifndef __NOD_DISC_GCN__
-#define __NOD_DISC_GCN__
+#pragma once
 
-#include "DiscBase.hpp"
+#include "nod/DiscBase.hpp"
 
-namespace nod
-{
+namespace nod {
 class DiscBuilderGCN;
 
-class DiscGCN : public DiscBase
-{
+class DiscGCN : public DiscBase {
   friend class DiscMergerGCN;
-    DiscBuilderGCN makeMergeBuilder(const SystemChar* outPath, FProgress progressCB);
+  DiscBuilderGCN makeMergeBuilder(SystemStringView outPath, FProgress progressCB);
+
 public:
   DiscGCN(std::unique_ptr<IDiscIO>&& dio, bool& err);
-    bool extractDiscHeaderFiles(const SystemString& path, const ExtractionContext& ctx) const;
+  bool extractDiscHeaderFiles(SystemStringView path, const ExtractionContext& ctx) const override;
 };
 
-class DiscBuilderGCN : public DiscBuilderBase
-{
+class DiscBuilderGCN : public DiscBuilderBase {
   friend class DiscMergerGCN;
+
 public:
-    DiscBuilderGCN(const SystemChar* outPath, FProgress progressCB);
-    EBuildResult buildFromDirectory(const SystemChar* dirIn);
-    static uint64_t CalculateTotalSizeRequired(const SystemChar* dirIn);
+  DiscBuilderGCN(SystemStringView outPath, FProgress progressCB);
+  EBuildResult buildFromDirectory(SystemStringView dirIn);
+  static uint64_t CalculateTotalSizeRequired(SystemStringView dirIn);
 };
 
-class DiscMergerGCN
-{
+class DiscMergerGCN {
   DiscGCN& m_sourceDisc;
   DiscBuilderGCN m_builder;
+
 public:
-    DiscMergerGCN(const SystemChar* outPath, DiscGCN& sourceDisc, FProgress progressCB);
-    EBuildResult mergeFromDirectory(const SystemChar* dirIn);
-    static uint64_t CalculateTotalSizeRequired(DiscGCN& sourceDisc, const SystemChar* dirIn);
+  DiscMergerGCN(SystemStringView outPath, DiscGCN& sourceDisc, FProgress progressCB);
+  EBuildResult mergeFromDirectory(SystemStringView dirIn);
+  static uint64_t CalculateTotalSizeRequired(DiscGCN& sourceDisc, SystemStringView dirIn);
 };
 
-}
-
-
-#endif // __NOD_DISC_GCN__
+} // namespace nod

include/nod/DiscWii.hpp

@@ -1,41 +1,32 @@
-#ifndef __NOD_DISC_WII__
-#define __NOD_DISC_WII__
+#pragma once
 
-#include "DiscBase.hpp"
+#include "nod/DiscBase.hpp"
 
-namespace nod
-{
+namespace nod {
 class DiscBuilderWii;
 
-class DiscWii : public DiscBase
-{
+class DiscWii : public DiscBase {
 public:
   DiscWii(std::unique_ptr<IDiscIO>&& dio, bool& err);
-    DiscBuilderWii makeMergeBuilder(const SystemChar* outPath, bool dualLayer, FProgress progressCB);
-    bool extractDiscHeaderFiles(const SystemString& path, const ExtractionContext& ctx) const;
+  DiscBuilderWii makeMergeBuilder(SystemStringView outPath, bool dualLayer, FProgress progressCB);
+  bool extractDiscHeaderFiles(SystemStringView path, const ExtractionContext& ctx) const override;
 };
 
-class DiscBuilderWii : public DiscBuilderBase
-{
-    bool m_dualLayer;
+class DiscBuilderWii : public DiscBuilderBase {
 public:
-    DiscBuilderWii(const SystemChar* outPath, bool dualLayer, FProgress progressCB);
-    EBuildResult buildFromDirectory(const SystemChar* dirIn);
-    static uint64_t CalculateTotalSizeRequired(const SystemChar* dirIn, bool& dualLayer);
+  DiscBuilderWii(SystemStringView outPath, bool dualLayer, FProgress progressCB);
+  EBuildResult buildFromDirectory(SystemStringView dirIn);
+  static uint64_t CalculateTotalSizeRequired(SystemStringView dirIn, bool& dualLayer);
 };
 
-class DiscMergerWii
-{
+class DiscMergerWii {
   DiscWii& m_sourceDisc;
   DiscBuilderWii m_builder;
+
 public:
-    DiscMergerWii(const SystemChar* outPath, DiscWii& sourceDisc,
-                  bool dualLayer, FProgress progressCB);
-    EBuildResult mergeFromDirectory(const SystemChar* dirIn);
-    static uint64_t CalculateTotalSizeRequired(DiscWii& sourceDisc, const SystemChar* dirIn,
-                                               bool& dualLayer);
+  DiscMergerWii(SystemStringView outPath, DiscWii& sourceDisc, bool dualLayer, FProgress progressCB);
+  EBuildResult mergeFromDirectory(SystemStringView dirIn);
+  static uint64_t CalculateTotalSizeRequired(DiscWii& sourceDisc, SystemStringView dirIn, bool& dualLayer);
 };
 
-}
-
-#endif // __NOD_DISC_WII__
+} // namespace nod

include/nod/IDiscIO.hpp

@@ -1,75 +1,67 @@
-#ifndef __NOD_IDISC_IO__
-#define __NOD_IDISC_IO__
+#pragma once
 
+#include <cstdint>
+#include <cstdio>
 #include <memory>
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdint.h>
 
 #if NOD_ATHENA
 #include <athena/IStreamReader.hpp>
 #include <athena/IStreamWriter.hpp>
 #endif
 
-namespace nod
-{
+namespace nod {
 
-struct IReadStream
-{
+struct IReadStream {
   virtual ~IReadStream() = default;
-    virtual uint64_t read(void* buf, uint64_t length)=0;
-    virtual void seek(int64_t offset, int whence=SEEK_SET)=0;
-    virtual uint64_t position() const=0;
+  virtual uint64_t read(void* buf, uint64_t length) = 0;
+  virtual void seek(int64_t offset, int whence = SEEK_SET) = 0;
+  virtual uint64_t position() const = 0;
 };
 
-struct IWriteStream
-{
+struct IWriteStream {
   virtual ~IWriteStream() = default;
-    virtual uint64_t write(const void* buf, uint64_t length)=0;
+  virtual uint64_t write(const void* buf, uint64_t length) = 0;
 };
 
-class IDiscIO
-{
+class IDiscIO {
 public:
   virtual ~IDiscIO() = default;
-    virtual std::unique_ptr<IReadStream> beginReadStream(uint64_t offset=0) const=0;
-    virtual std::unique_ptr<IWriteStream> beginWriteStream(uint64_t offset=0) const=0;
+  virtual std::unique_ptr<IReadStream> beginReadStream(uint64_t offset = 0) const = 0;
+  virtual std::unique_ptr<IWriteStream> beginWriteStream(uint64_t offset = 0) const = 0;
 };
 
-struct IPartReadStream : IReadStream
-{
-    virtual ~IPartReadStream() = default;
+struct IPartReadStream : IReadStream {
+  ~IPartReadStream() override = default;
 };
 
-struct IPartWriteStream : IWriteStream
-{
-    virtual ~IPartWriteStream() = default;
-    virtual void close()=0;
-    virtual uint64_t position() const=0;
+struct IPartWriteStream : IWriteStream {
+  ~IPartWriteStream() override = default;
+  virtual void close() = 0;
+  virtual uint64_t position() const = 0;
 };
 
 #if NOD_ATHENA
 
-class AthenaPartReadStream : public athena::io::IStreamReader
-{
+class AthenaPartReadStream : public athena::io::IStreamReader {
   std::unique_ptr<IPartReadStream> m_rs;
+
 public:
   AthenaPartReadStream(std::unique_ptr<IPartReadStream>&& rs) : m_rs(std::move(rs)) {}
 
-    inline void seek(atInt64 off, athena::SeekOrigin origin)
-    {
+  void seek(atInt64 off, athena::SeekOrigin origin) override {
     if (origin == athena::Begin)
       m_rs->seek(off, SEEK_SET);
     else if (origin == athena::Current)
       m_rs->seek(off, SEEK_CUR);
   }
-    inline atUint64 position()    const {return m_rs->position();}
-    inline atUint64 length()      const {return 0;}
-    inline atUint64 readUBytesToBuf(void* buf, atUint64 sz) {m_rs->read(buf, sz); return sz;}
+  atUint64 position() const override { return m_rs->position(); }
+  atUint64 length() const override { return 0; }
+  atUint64 readUBytesToBuf(void* buf, atUint64 sz) override {
+    m_rs->read(buf, sz);
+    return sz;
+  }
 };
 
 #endif
 
-}
-
-#endif // __NOD_IDISC_IO__
+} // namespace nod

include/nod/IFileIO.hpp

@@ -1,40 +1,35 @@
-#ifndef __NOD_IFILE_IO__
-#define __NOD_IFILE_IO__
+#pragma once
 
-#include <memory>
+#include <cstdint>
 #include <functional>
-#include <stdlib.h>
-#include "IDiscIO.hpp"
-#include "Util.hpp"
+#include <memory>
 
-namespace nod
-{
+#include "nod/IDiscIO.hpp"
+#include "nod/Util.hpp"
 
-class IFileIO
-{
+#include <logvisor/logvisor.hpp>
+
+namespace nod {
+
+class IFileIO {
 public:
   virtual ~IFileIO() = default;
-    virtual bool exists()=0;
-    virtual uint64_t size()=0;
+  virtual bool exists() = 0;
+  virtual uint64_t size() = 0;
 
-    struct IWriteStream : nod::IWriteStream
-    {
-        uint64_t copyFromDisc(IPartReadStream& discio, uint64_t length)
-        {
+  struct IWriteStream : nod::IWriteStream {
+    uint64_t copyFromDisc(IPartReadStream& discio, uint64_t length) {
       uint64_t read = 0;
       uint8_t buf[0x7c00];
-            while (length)
-            {
+      while (length) {
         uint64_t thisSz = nod::min(uint64_t(0x7c00), length);
         uint64_t readSz = discio.read(buf, thisSz);
-                if (thisSz != readSz)
-                {
-                    LogModule.report(logvisor::Error, "unable to read enough from disc");
+        if (thisSz != readSz) {
+          LogModule.report(logvisor::Error, fmt("unable to read enough from disc"));
           return read;
         }
-                if (write(buf, readSz) != readSz)
-                {
-                    LogModule.report(logvisor::Error, "unable to write in file");
+        if (write(buf, readSz) != readSz) {
+          LogModule.report(logvisor::Error, fmt("unable to write in file"));
           return read;
         }
         length -= thisSz;
@@ -42,23 +37,19 @@ public:
       }
       return read;
     }
-        uint64_t copyFromDisc(IPartReadStream& discio, uint64_t length, const std::function<void(float)>& prog)
-        {
+    uint64_t copyFromDisc(IPartReadStream& discio, uint64_t length, const std::function<void(float)>& prog) {
       uint64_t read = 0;
       uint8_t buf[0x7c00];
       uint64_t total = length;
-            while (length)
-            {
+      while (length) {
         uint64_t thisSz = nod::min(uint64_t(0x7c00), length);
         uint64_t readSz = discio.read(buf, thisSz);
-                if (thisSz != readSz)
-                {
-                    LogModule.report(logvisor::Error, "unable to read enough from disc");
+        if (thisSz != readSz) {
+          LogModule.report(logvisor::Error, fmt("unable to read enough from disc"));
           return read;
         }
-                if (write(buf, readSz) != readSz)
-                {
-                    LogModule.report(logvisor::Error, "unable to write in file");
+        if (write(buf, readSz) != readSz) {
+          LogModule.report(logvisor::Error, fmt("unable to write in file"));
           return read;
         }
         length -= thisSz;
@@ -68,20 +59,16 @@ public:
       return read;
     }
   };
-    virtual std::unique_ptr<IWriteStream> beginWriteStream() const=0;
-    virtual std::unique_ptr<IWriteStream> beginWriteStream(uint64_t offset) const=0;
+  virtual std::unique_ptr<IWriteStream> beginWriteStream() const = 0;
+  virtual std::unique_ptr<IWriteStream> beginWriteStream(uint64_t offset) const = 0;
 
-    struct IReadStream : nod::IReadStream
-    {
-        virtual uint64_t copyToDisc(struct IPartWriteStream& discio, uint64_t length)=0;
+  struct IReadStream : nod::IReadStream {
+    virtual uint64_t copyToDisc(struct IPartWriteStream& discio, uint64_t length) = 0;
   };
-    virtual std::unique_ptr<IReadStream> beginReadStream() const=0;
-    virtual std::unique_ptr<IReadStream> beginReadStream(uint64_t offset) const=0;
+  virtual std::unique_ptr<IReadStream> beginReadStream() const = 0;
+  virtual std::unique_ptr<IReadStream> beginReadStream(uint64_t offset) const = 0;
 };
 
-std::unique_ptr<IFileIO> NewFileIO(const SystemString& path, int64_t maxWriteSize=-1);
-std::unique_ptr<IFileIO> NewFileIO(const SystemChar* path, int64_t maxWriteSize=-1);
+std::unique_ptr<IFileIO> NewFileIO(SystemStringView path, int64_t maxWriteSize = -1);
 
-}
-
-#endif // __NOD_IFILE_IO__
+} // namespace nod

include/nod/Util.hpp

@@ -1,8 +1,7 @@
-#ifndef __NOD_UTIL_HPP__
-#define __NOD_UTIL_HPP__
+#pragma once
 
 #if _WIN32 && UNICODE
-#include <wctype.h>
+#include <cwctype>
 #include <direct.h>
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN 1
@@ -11,32 +10,37 @@
 #define NOMINMAX
 #endif
 #include <windows.h>
+#if defined(WINAPI_FAMILY) && WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP
+#define WINDOWS_STORE 1
 #else
-#include <ctype.h>
+#define WINDOWS_STORE 0
+#endif
+#else
+#include <cctype>
+#include <cerrno>
 #include <sys/file.h>
-#include <unistd.h>
-#include <errno.h>
 #include <sys/param.h>
 #include <sys/statvfs.h>
-
+#include <unistd.h>
 #endif
 #include <sys/stat.h>
 
-#include <string>
-#include <cstring>
 #include <algorithm>
-#include "logvisor/logvisor.hpp"
+#include <cstring>
+#include <string>
+#include <string_view>
+#include <logvisor/logvisor.hpp>
 #ifdef _MSC_VER
 #pragma warning(disable : 4996)
 
 #include <sys/stat.h>
 
 #if !defined(S_ISREG) && defined(S_IFMT) && defined(S_IFREG)
-#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
+#define S_ISREG(m) (((m)&S_IFMT) == S_IFREG)
 #endif
 
 #if !defined(S_ISDIR) && defined(S_IFMT) && defined(S_IFDIR)
-#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
+#define S_ISDIR(m) (((m)&S_IFMT) == S_IFDIR)
 #endif
 
 #if !defined(S_ISLNK)
@@ -47,13 +51,16 @@
 #undef min
 #undef max
 
-namespace nod
-{
+namespace nod {
 /* define our own min/max to avoid MSVC BS */
-template<typename T>
-inline T min(T a, T b) { return a < b ? a : b; }
-template<typename T>
-inline T max(T a, T b) { return a > b ? a : b; }
+template <typename T>
+inline T min(T a, T b) {
+  return a < b ? a : b;
+}
+template <typename T>
+inline T max(T a, T b) {
+  return a > b ? a : b;
+}
 
 /* Log Module */
 extern logvisor::Module LogModule;
@@ -62,81 +69,78 @@ extern logvisor::Module LogModule;
 #if _WIN32 && UNICODE
 #define NOD_UCS2 1
 typedef struct _stat Sstat;
-static inline int Mkdir(const wchar_t* path, int) {return _wmkdir(path);}
-static inline int Stat(const wchar_t* path, Sstat* statout) {return _wstat(path, statout);}
+static inline int Mkdir(const wchar_t* path, int) { return _wmkdir(path); }
+static inline int Stat(const wchar_t* path, Sstat* statout) { return _wstat(path, statout); }
 #else
 typedef struct stat Sstat;
-static inline int Mkdir(const char* path, mode_t mode) {return mkdir(path, mode);}
-static inline int Stat(const char* path, Sstat* statout) {return stat(path, statout);}
+static inline int Mkdir(const char* path, mode_t mode) { return mkdir(path, mode); }
+static inline int Stat(const char* path, Sstat* statout) { return stat(path, statout); }
 #endif
 
 /* String-converting views */
 #if NOD_UCS2
 typedef wchar_t SystemChar;
 typedef std::wstring SystemString;
-static inline void ToLower(SystemString& str)
-{std::transform(str.begin(), str.end(), str.begin(), towlower);}
-static inline void ToUpper(SystemString& str)
-{std::transform(str.begin(), str.end(), str.begin(), towupper);}
-static inline size_t StrLen(const SystemChar* str) {return wcslen(str);}
-class SystemUTF8View
-{
+typedef std::wstring_view SystemStringView;
+static inline void ToLower(SystemString& str) { std::transform(str.begin(), str.end(), str.begin(), towlower); }
+static inline void ToUpper(SystemString& str) { std::transform(str.begin(), str.end(), str.begin(), towupper); }
+static inline size_t StrLen(const SystemChar* str) { return wcslen(str); }
+class SystemUTF8Conv {
   std::string m_utf8;
+
 public:
-    explicit SystemUTF8View(const SystemString& str)
-    {
-        int len = WideCharToMultiByte(CP_UTF8, 0, str.c_str(), str.size(), nullptr, 0, nullptr, nullptr);
+  explicit SystemUTF8Conv(SystemStringView str) {
+    int len = WideCharToMultiByte(CP_UTF8, 0, str.data(), str.size(), nullptr, 0, nullptr, nullptr);
     m_utf8.assign(len, '\0');
-        WideCharToMultiByte(CP_UTF8, 0, str.c_str(), str.size(), &m_utf8[0], len, nullptr, nullptr);
+    WideCharToMultiByte(CP_UTF8, 0, str.data(), str.size(), &m_utf8[0], len, nullptr, nullptr);
   }
-    inline const std::string& utf8_str() {return m_utf8;}
+  std::string_view utf8_str() const { return m_utf8; }
+  const char* c_str() const { return m_utf8.c_str(); }
 };
-class SystemStringView
-{
+class SystemStringConv {
   std::wstring m_sys;
+
 public:
-    explicit SystemStringView(const std::string& str)
-    {
-        int len = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), str.size(), nullptr, 0);
+  explicit SystemStringConv(std::string_view str) {
+    int len = MultiByteToWideChar(CP_UTF8, 0, str.data(), str.size(), nullptr, 0);
     m_sys.assign(len, L'\0');
-        MultiByteToWideChar(CP_UTF8, 0, str.c_str(), str.size(), &m_sys[0], len);
+    MultiByteToWideChar(CP_UTF8, 0, str.data(), str.size(), &m_sys[0], len);
   }
-    inline const std::wstring& sys_str() {return m_sys;}
+  SystemStringView sys_str() const { return m_sys; }
+  const SystemChar* c_str() const { return m_sys.c_str(); }
 };
-#ifndef _S
-#define _S(val) L ## val
+#ifndef _SYS_STR
+#define _SYS_STR(val) L##val
 #endif
 #else
 typedef char SystemChar;
 typedef std::string SystemString;
-static inline void ToLower(SystemString& str)
-{std::transform(str.begin(), str.end(), str.begin(), tolower);}
-static inline void ToUpper(SystemString& str)
-{std::transform(str.begin(), str.end(), str.begin(), toupper);}
-static inline size_t StrLen(const SystemChar* str) {return strlen(str);}
-class SystemUTF8View
-{
-    const std::string& m_utf8;
+typedef std::string_view SystemStringView;
+static inline void ToLower(SystemString& str) { std::transform(str.begin(), str.end(), str.begin(), tolower); }
+static inline void ToUpper(SystemString& str) { std::transform(str.begin(), str.end(), str.begin(), toupper); }
+static inline size_t StrLen(const SystemChar* str) { return strlen(str); }
+class SystemUTF8Conv {
+  std::string_view m_utf8;
+
 public:
-    explicit SystemUTF8View(const SystemString& str)
-    : m_utf8(str) {}
-    inline const std::string& utf8_str() {return m_utf8;}
+  explicit SystemUTF8Conv(SystemStringView str) : m_utf8(str) {}
+  std::string_view utf8_str() const { return m_utf8; }
+  const char* c_str() const { return m_utf8.data(); }
 };
-class SystemStringView
-{
-    const std::string& m_sys;
+class SystemStringConv {
+  SystemStringView m_sys;
+
 public:
-    explicit SystemStringView(const std::string& str)
-    : m_sys(str) {}
-    inline const std::string& sys_str() {return m_sys;}
+  explicit SystemStringConv(std::string_view str) : m_sys(str) {}
+  SystemStringView sys_str() const { return m_sys; }
+  const SystemChar* c_str() const { return m_sys.data(); }
 };
-#ifndef _S
-#define _S(val) val
+#ifndef _SYS_STR
+#define _SYS_STR(val) val
 #endif
 #endif
 
-static inline void Unlink(const SystemChar* file)
-{
+static inline void Unlink(const SystemChar* file) {
 #if NOD_UCS2
   _wunlink(file);
 #else
@@ -144,8 +148,7 @@ static inline void Unlink(const SystemChar* file)
 #endif
 }
 
-static inline int StrCmp(const SystemChar* str1, const SystemChar* str2)
-{
+static inline int StrCmp(const SystemChar* str1, const SystemChar* str2) {
 #if NOD_UCS2
   return wcscmp(str1, str2);
 #else
@@ -153,8 +156,7 @@ static inline int StrCmp(const SystemChar* str1, const SystemChar* str2)
 #endif
 }
 
-static inline int StrCaseCmp(const SystemChar* str1, const SystemChar* str2)
-{
+static inline int StrCaseCmp(const SystemChar* str1, const SystemChar* str2) {
 #if NOD_UCS2
   return _wcsicmp(str1, str2);
 #else
@@ -167,8 +169,7 @@ static inline int StrCaseCmp(const SystemChar* str1, const SystemChar* str2)
 #undef bswap64
 /* Type-sensitive byte swappers */
 template <typename T>
-static inline T bswap16(T val)
-{
+static inline T bswap16(T val) {
 #if __GNUC__
   return __builtin_bswap16(val);
 #elif _WIN32
@@ -179,8 +180,7 @@ static inline T bswap16(T val)
 }
 
 template <typename T>
-static inline T bswap32(T val)
-{
+static inline T bswap32(T val) {
 #if __GNUC__
   return __builtin_bswap32(val);
 #elif _WIN32
@@ -193,53 +193,47 @@ static inline T bswap32(T val)
 }
 
 template <typename T>
-static inline T bswap64(T val)
-{
+static inline T bswap64(T val) {
 #if __GNUC__
   return __builtin_bswap64(val);
 #elif _WIN32
   return _byteswap_uint64(val);
 #else
-    return ((val & 0xFF00000000000000ULL) >> 56) |
-           ((val & 0x00FF000000000000ULL) >> 40) |
-           ((val & 0x0000FF0000000000ULL) >> 24) |
-           ((val & 0x000000FF00000000ULL) >>  8) |
-           ((val & 0x00000000FF000000ULL) <<  8) |
-           ((val & 0x0000000000FF0000ULL) << 24) |
-           ((val & 0x000000000000FF00ULL) << 40) |
-           ((val & 0x00000000000000FFULL) << 56);
+  return ((val & 0xFF00000000000000ULL) >> 56) | ((val & 0x00FF000000000000ULL) >> 40) |
+         ((val & 0x0000FF0000000000ULL) >> 24) | ((val & 0x000000FF00000000ULL) >> 8) |
+         ((val & 0x00000000FF000000ULL) << 8) | ((val & 0x0000000000FF0000ULL) << 24) |
+         ((val & 0x000000000000FF00ULL) << 40) | ((val & 0x00000000000000FFULL) << 56);
 #endif
 }
 
-
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-static inline int16_t SBig(int16_t val) {return bswap16(val);}
-static inline uint16_t SBig(uint16_t val) {return bswap16(val);}
-static inline int32_t SBig(int32_t val) {return bswap32(val);}
-static inline uint32_t SBig(uint32_t val) {return bswap32(val);}
-static inline int64_t SBig(int64_t val) {return bswap64(val);}
-static inline uint64_t SBig(uint64_t val) {return bswap64(val);}
+static inline int16_t SBig(int16_t val) { return bswap16(val); }
+static inline uint16_t SBig(uint16_t val) { return bswap16(val); }
+static inline int32_t SBig(int32_t val) { return bswap32(val); }
+static inline uint32_t SBig(uint32_t val) { return bswap32(val); }
+static inline int64_t SBig(int64_t val) { return bswap64(val); }
+static inline uint64_t SBig(uint64_t val) { return bswap64(val); }
 
-static inline int16_t SLittle(int16_t val) {return val;}
-static inline uint16_t SLittle(uint16_t val) {return val;}
-static inline int32_t SLittle(int32_t val) {return val;}
-static inline uint32_t SLittle(uint32_t val) {return val;}
-static inline int64_t SLittle(int64_t val) {return val;}
-static inline uint64_t SLittle(uint64_t val) {return val;}
+static inline int16_t SLittle(int16_t val) { return val; }
+static inline uint16_t SLittle(uint16_t val) { return val; }
+static inline int32_t SLittle(int32_t val) { return val; }
+static inline uint32_t SLittle(uint32_t val) { return val; }
+static inline int64_t SLittle(int64_t val) { return val; }
+static inline uint64_t SLittle(uint64_t val) { return val; }
 #else
-static inline int16_t SLittle(int16_t val) {return bswap16(val);}
-static inline uint16_t SLittle(uint16_t val) {return bswap16(val);}
-static inline int32_t SLittle(int32_t val) {return bswap32(val);}
-static inline uint32_t SLittle(uint32_t val) {return bswap32(val);}
-static inline int64_t SLittle(int64_t val) {return bswap64(val);}
-static inline uint64_t SLittle(uint64_t val) {return bswap64(val);}
+static inline int16_t SLittle(int16_t val) { return bswap16(val); }
+static inline uint16_t SLittle(uint16_t val) { return bswap16(val); }
+static inline int32_t SLittle(int32_t val) { return bswap32(val); }
+static inline uint32_t SLittle(uint32_t val) { return bswap32(val); }
+static inline int64_t SLittle(int64_t val) { return bswap64(val); }
+static inline uint64_t SLittle(uint64_t val) { return bswap64(val); }
 
-static inline int16_t SBig(int16_t val) {return val;}
-static inline uint16_t SBig(uint16_t val) {return val;}
-static inline int32_t SBig(int32_t val) {return val;}
-static inline uint32_t SBig(uint32_t val) {return val;}
-static inline int64_t SBig(int64_t val) {return val;}
-static inline uint64_t SBig(uint64_t val) {return val;}
+static inline int16_t SBig(int16_t val) { return val; }
+static inline uint16_t SBig(uint16_t val) { return val; }
+static inline int32_t SBig(int32_t val) { return val; }
+static inline uint32_t SBig(uint32_t val) { return val; }
+static inline int64_t SBig(int64_t val) { return val; }
+static inline uint64_t SBig(uint64_t val) { return val; }
 #endif
 
 #ifndef ROUND_UP_32
@@ -247,14 +241,8 @@ static inline uint64_t SBig(uint64_t val) {return val;}
 #define ROUND_UP_16(val) (((val) + 15) & ~15)
 #endif
 
-enum class FileLockType
-{
-    None = 0,
-    Read,
-    Write
-};
-static inline FILE* Fopen(const SystemChar* path, const SystemChar* mode, FileLockType lock=FileLockType::None)
-{
+enum class FileLockType { None = 0, Read, Write };
+static inline FILE* Fopen(const SystemChar* path, const SystemChar* mode, FileLockType lock = FileLockType::None) {
 #if NOD_UCS2
   FILE* fp = _wfopen(path, mode);
   if (!fp)
@@ -265,22 +253,21 @@ static inline FILE* Fopen(const SystemChar* path, const SystemChar* mode, FileLo
     return nullptr;
 #endif
 
-    if (lock != FileLockType::None)
-    {
+  if (lock != FileLockType::None) {
 #if _WIN32
     OVERLAPPED ov = {};
-        LockFileEx((HANDLE)(uintptr_t)_fileno(fp), (lock == FileLockType::Write) ? LOCKFILE_EXCLUSIVE_LOCK : 0, 0, 0, 1, &ov);
+    LockFileEx((HANDLE)(uintptr_t)_fileno(fp), (lock == FileLockType::Write) ? LOCKFILE_EXCLUSIVE_LOCK : 0, 0, 0, 1,
+               &ov);
 #else
     if (flock(fileno(fp), ((lock == FileLockType::Write) ? LOCK_EX : LOCK_SH) | LOCK_NB))
-            LogModule.report(logvisor::Error, "flock %s: %s", path, strerror(errno));
+      LogModule.report(logvisor::Error, fmt("flock {}: {}"), path, strerror(errno));
 #endif
   }
 
   return fp;
 }
 
-static inline int FSeek(FILE* fp, int64_t offset, int whence)
-{
+static inline int FSeek(FILE* fp, int64_t offset, int whence) {
 #if _WIN32
   return _fseeki64(fp, offset, whence);
 #elif __APPLE__ || __FreeBSD__
@@ -290,8 +277,7 @@ static inline int FSeek(FILE* fp, int64_t offset, int whence)
 #endif
 }
 
-static inline int64_t FTell(FILE* fp)
-{
+static inline int64_t FTell(FILE* fp) {
 #if _WIN32
   return _ftelli64(fp);
 #elif __APPLE__ || __FreeBSD__
@@ -301,52 +287,31 @@ static inline int64_t FTell(FILE* fp)
 #endif
 }
 
-static inline bool CheckFreeSpace(const SystemChar* path, size_t reqSz)
-{
+static inline bool CheckFreeSpace(const SystemChar* path, size_t reqSz) {
 #if _WIN32
   ULARGE_INTEGER freeBytes;
   wchar_t buf[1024];
   wchar_t* end;
   DWORD ret = GetFullPathNameW(path, 1024, buf, &end);
-    if (!ret || ret > 1024)
-    {
-        LogModule.report(logvisor::Error, _S("GetFullPathNameW %s"), path);
+  if (!ret || ret > 1024) {
+    LogModule.report(logvisor::Error, fmt(_SYS_STR("GetFullPathNameW {}")), path);
     return false;
   }
   if (end)
     end[0] = L'\0';
-    if (!GetDiskFreeSpaceExW(buf, &freeBytes, nullptr, nullptr))
-    {
-        LogModule.report(logvisor::Error, _S("GetDiskFreeSpaceExW %s: %d"), path, GetLastError());
+  if (!GetDiskFreeSpaceExW(buf, &freeBytes, nullptr, nullptr)) {
+    LogModule.report(logvisor::Error, fmt(_SYS_STR("GetDiskFreeSpaceExW {}: {}")), path, GetLastError());
     return false;
   }
   return reqSz < freeBytes.QuadPart;
 #else
   struct statvfs svfs;
-    if (statvfs(path, &svfs))
-    {
-        LogModule.report(logvisor::Error, "statvfs %s: %s", path, strerror(errno));
+  if (statvfs(path, &svfs)) {
+    LogModule.report(logvisor::Error, fmt("statvfs {}: {}"), path, strerror(errno));
     return false;
   }
   return reqSz < svfs.f_frsize * svfs.f_bavail;
 #endif
 }
 
-#if __GNUC__
-__attribute__((__format__ (__printf__, 1, 2)))
-#endif
-static inline void Printf(const SystemChar* fmt, ...)
-{
-    va_list args;
-    va_start(args, fmt);
-#if NOD_UCS2
-    vwprintf(fmt, args);
-#else
-    vprintf(fmt, args);
-#endif
-    va_end(args);
-}
-
-}
-
-#endif // __NOD_UTIL_HPP__
+} // namespace nod

include/nod/aes.hpp

@@ -1,24 +1,19 @@
-#ifndef __AES_HPP__
-#define __AES_HPP__
+#pragma once
 
-#include <stdint.h>
-#include <stdlib.h>
+#include <cstdint>
+#include <cstdlib>
 #include <memory>
 
-namespace nod
-{
+namespace nod {
 
-class IAES
-{
+class IAES {
 public:
   virtual ~IAES() = default;
-    virtual void encrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outbuf, size_t len)=0;
-    virtual void decrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outbuf, size_t len)=0;
-    virtual void setKey(const uint8_t* key)=0;
+  virtual void encrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outbuf, size_t len) = 0;
+  virtual void decrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outbuf, size_t len) = 0;
+  virtual void setKey(const uint8_t* key) = 0;
 };
 
 std::unique_ptr<IAES> NewAES();
 
-}
-
-#endif //__AES_HPP__
+} // namespace nod

include/nod/nod.hpp

@@ -1,29 +1,21 @@
-#ifndef __NOD_LIB__
-#define __NOD_LIB__
+#pragma once
 
-#include <memory>
 #include <functional>
-#include "logvisor/logvisor.hpp"
-#include "Util.hpp"
+#include <memory>
+#include <string>
 
-namespace nod
-{
+#include "nod/Util.hpp"
+
+namespace nod {
 
 class DiscBase;
 
-struct ExtractionContext final
-{
+struct ExtractionContext final {
   bool force : 1;
-    std::function<void(const std::string&, float)> progressCB;
+  std::function<void(std::string_view, float)> progressCB;
 };
 
-std::unique_ptr<DiscBase> OpenDiscFromImage(const SystemChar* path);
-std::unique_ptr<DiscBase> OpenDiscFromImage(const SystemChar* path, bool& isWii);
+std::unique_ptr<DiscBase> OpenDiscFromImage(SystemStringView path);
+std::unique_ptr<DiscBase> OpenDiscFromImage(SystemStringView path, bool& isWii);
 
-}
-
-#include "DiscGCN.hpp"
-#include "DiscWii.hpp"
-#include "IDiscIO.hpp"
-
-#endif // __NOD_LIB__
+} // namespace nod

lib/CMakeLists.txt

@@ -1,21 +1,50 @@
-if(NOT WIN32)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-multichar")
-set(PLAT_SRCS FileIOFILE.cpp)
-else()
-set(PLAT_SRCS FileIOWin32.cpp)
-endif()
 add_library(nod
   aes.cpp
   sha1.c
+
+  DirectoryEnumerator.cpp
   DiscBase.cpp
   DiscGCN.cpp
   DiscIOISO.cpp
   DiscIOWBFS.cpp
   DiscWii.cpp
-            DirectoryEnumerator.cpp
   nod.cpp
-			${PLAT_SRCS}
-            ${NOD_HEADERS})
-if(NOT MSVC)
-set_source_files_properties(aes.cpp PROPERTIES COMPILE_FLAGS -maes)
+
+  ../include/nod/aes.hpp
+  ../include/nod/DirectoryEnumerator.hpp
+  ../include/nod/DiscBase.hpp
+  ../include/nod/DiscGCN.hpp
+  ../include/nod/DiscWii.hpp
+  ../include/nod/IDiscIO.hpp
+  ../include/nod/IFileIO.hpp
+  ../include/nod/nod.hpp
+  ../include/nod/sha1.h
+  ../include/nod/Util.hpp
+)
+
+target_include_directories(nod PUBLIC
+  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include>
+)
+
+target_link_libraries(nod PUBLIC logvisor)
+
+if(WIN32)
+  target_sources(nod PRIVATE FileIOWin32.cpp)
+else()
+  target_compile_options(nod PRIVATE -Wno-multichar)
+  target_sources(nod PRIVATE FileIOFILE.cpp)
 endif()
+
+if(NOT MSVC AND NOT NX)
+  set_source_files_properties(aes.cpp PROPERTIES COMPILE_FLAGS -maes)
+endif()
+
+# Associate target with export
+install(
+    TARGETS nod
+    EXPORT nodTargets
+    ARCHIVE DESTINATION "lib"
+    INCLUDES DESTINATION include  # This sets the INTERFACE_INCLUDE_DIRECTORIES property of the target.
+)
+
+install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/../include/nod DESTINATION include)

lib/DirectoryEnumerator.cpp

@@ -1,3 +1,5 @@
+#include "nod/DirectoryEnumerator.hpp"
+
 #ifdef _WIN32
 #include <windows.h>
 #else
@@ -5,38 +7,32 @@
 #include <dirent.h>
 #endif
 
+#include <cstring>
 #include <map>
 
-#include "nod/DirectoryEnumerator.hpp"
+namespace nod {
 
-namespace nod
-{
-
-DirectoryEnumerator::DirectoryEnumerator(const SystemChar* path, Mode mode,
-                                         bool sizeSort, bool reverse, bool noHidden)
-{
+DirectoryEnumerator::DirectoryEnumerator(SystemStringView path, Mode mode, bool sizeSort, bool reverse, bool noHidden) {
   Sstat theStat;
-    if (Stat(path, &theStat) || !S_ISDIR(theStat.st_mode))
+  if (Stat(path.data(), &theStat) || !S_ISDIR(theStat.st_mode))
     return;
 
 #if _WIN32
   SystemString wc(path);
-    wc += _S("/*");
+  wc += _SYS_STR("/*");
   WIN32_FIND_DATAW d;
   HANDLE dir = FindFirstFileW(wc.c_str(), &d);
   if (dir == INVALID_HANDLE_VALUE)
     return;
-    switch (mode)
-    {
+  switch (mode) {
   case Mode::Native:
-        do
-        {
-            if (!wcscmp(d.cFileName, _S(".")) || !wcscmp(d.cFileName, _S("..")))
+    do {
+      if (!wcscmp(d.cFileName, _SYS_STR(".")) || !wcscmp(d.cFileName, _SYS_STR("..")))
         continue;
       if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0))
         continue;
       SystemString fp(path);
-            fp += _S('/');
+      fp += _SYS_STR('/');
       fp += d.cFileName;
       Sstat st;
       if (Stat(fp.c_str(), &st))
@@ -51,31 +47,29 @@ DirectoryEnumerator::DirectoryEnumerator(const SystemChar* path, Mode mode,
       else
         continue;
 
-            m_entries.push_back(std::move(Entry(std::move(fp), d.cFileName, sz, isDir)));
+      m_entries.push_back(Entry(fp, d.cFileName, sz, isDir));
     } while (FindNextFileW(dir, &d));
     break;
   case Mode::DirsThenFilesSorted:
-    case Mode::DirsSorted:
-    {
+  case Mode::DirsSorted: {
     std::map<SystemString, Entry, CaseInsensitiveCompare> sort;
-        do
-        {
-            if (!wcscmp(d.cFileName, _S(".")) || !wcscmp(d.cFileName, _S("..")))
+    do {
+      if (!wcscmp(d.cFileName, _SYS_STR(".")) || !wcscmp(d.cFileName, _SYS_STR("..")))
         continue;
       if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0))
         continue;
       SystemString fp(path);
-            fp +=_S('/');
+      fp += _SYS_STR('/');
       fp += d.cFileName;
       Sstat st;
       if (Stat(fp.c_str(), &st) || !S_ISDIR(st.st_mode))
         continue;
-            sort.emplace(std::make_pair(d.cFileName, Entry(std::move(fp), d.cFileName, 0, true)));
+      sort.emplace(std::make_pair(d.cFileName, Entry(fp, d.cFileName, 0, true)));
     } while (FindNextFileW(dir, &d));
 
     m_entries.reserve(sort.size());
     if (reverse)
-            for (auto it=sort.crbegin() ; it != sort.crend() ; ++it)
+      for (auto it = sort.crbegin(); it != sort.crend(); ++it)
         m_entries.push_back(std::move(it->second));
     else
       for (auto& e : sort)
@@ -86,58 +80,52 @@ DirectoryEnumerator::DirectoryEnumerator(const SystemChar* path, Mode mode,
     FindClose(dir);
     dir = FindFirstFileW(wc.c_str(), &d);
   }
-    case Mode::FilesSorted:
-    {
+  case Mode::FilesSorted: {
     if (mode == Mode::FilesSorted)
       m_entries.clear();
 
-        if (sizeSort)
-        {
+    if (sizeSort) {
       std::multimap<size_t, Entry> sort;
-            do
-            {
-                if (!wcscmp(d.cFileName, _S(".")) || !wcscmp(d.cFileName, _S("..")))
+      do {
+        if (!wcscmp(d.cFileName, _SYS_STR(".")) || !wcscmp(d.cFileName, _SYS_STR("..")))
           continue;
         if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0))
           continue;
         SystemString fp(path);
-                fp += _S('/');
+        fp += _SYS_STR('/');
         fp += d.cFileName;
         Sstat st;
         if (Stat(fp.c_str(), &st) || !S_ISREG(st.st_mode))
           continue;
-                sort.emplace(std::make_pair(st.st_size, Entry(std::move(fp), d.cFileName, st.st_size, false)));
+        sort.emplace(std::make_pair(st.st_size, Entry(fp, d.cFileName, st.st_size, false)));
       } while (FindNextFileW(dir, &d));
 
       m_entries.reserve(sort.size());
       if (reverse)
-                for (auto it=sort.crbegin() ; it != sort.crend() ; ++it)
+        for (auto it = sort.crbegin(); it != sort.crend(); ++it)
           m_entries.push_back(std::move(it->second));
       else
         for (auto& e : sort)
           m_entries.push_back(std::move(e.second));
-        }
-        else
-        {
+    } else {
       std::map<SystemString, Entry, CaseInsensitiveCompare> sort;
-            do
-            {
-                if (!wcscmp(d.cFileName, _S(".")) || !wcscmp(d.cFileName, _S("..")))
+      do {
+        if (!wcscmp(d.cFileName, _SYS_STR(".")) || !wcscmp(d.cFileName, _SYS_STR("..")))
           continue;
         if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0))
           continue;
         SystemString fp(path);
-                fp += _S('/');
+        fp += _SYS_STR('/');
         fp += d.cFileName;
         Sstat st;
         if (Stat(fp.c_str(), &st) || !S_ISREG(st.st_mode))
           continue;
-                sort.emplace(std::make_pair(d.cFileName, Entry(std::move(fp), d.cFileName, st.st_size, false)));
+        sort.emplace(std::make_pair(d.cFileName, Entry(fp, d.cFileName, st.st_size, false)));
       } while (FindNextFileW(dir, &d));
 
       m_entries.reserve(sort.size());
       if (reverse)
-                for (auto it=sort.crbegin() ; it != sort.crend() ; ++it)
+        for (auto it = sort.crbegin(); it != sort.crend(); ++it)
           m_entries.push_back(std::move(it->second));
       else
         for (auto& e : sort)
@@ -151,15 +139,13 @@ DirectoryEnumerator::DirectoryEnumerator(const SystemChar* path, Mode mode,
 
 #else
 
-    DIR* dir = opendir(path);
+  DIR* dir = opendir(path.data());
   if (!dir)
     return;
   const dirent* d;
-    switch (mode)
-    {
+  switch (mode) {
   case Mode::Native:
-        while ((d = readdir(dir)))
-        {
+    while ((d = readdir(dir))) {
       if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
         continue;
       if (noHidden && d->d_name[0] == '.')
@@ -180,15 +166,13 @@ DirectoryEnumerator::DirectoryEnumerator(const SystemChar* path, Mode mode,
       else
         continue;
 
-            m_entries.push_back(Entry(std::move(fp), d->d_name, sz, isDir));
+      m_entries.push_back(Entry(fp, d->d_name, sz, isDir));
     }
     break;
   case Mode::DirsThenFilesSorted:
-    case Mode::DirsSorted:
-    {
+  case Mode::DirsSorted: {
     std::map<SystemString, Entry, CaseInsensitiveCompare> sort;
-        while ((d = readdir(dir)))
-        {
+    while ((d = readdir(dir))) {
       if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
         continue;
       if (noHidden && d->d_name[0] == '.')
@@ -199,12 +183,12 @@ DirectoryEnumerator::DirectoryEnumerator(const SystemChar* path, Mode mode,
       Sstat st;
       if (Stat(fp.c_str(), &st) || !S_ISDIR(st.st_mode))
         continue;
-            sort.emplace(std::make_pair(d->d_name, Entry(std::move(fp), d->d_name, 0, true)));
+      sort.emplace(std::make_pair(d->d_name, Entry(fp, d->d_name, 0, true)));
     }
 
     m_entries.reserve(sort.size());
     if (reverse)
-            for (auto it=sort.crbegin() ; it != sort.crend() ; ++it)
+      for (auto it = sort.crbegin(); it != sort.crend(); ++it)
         m_entries.push_back(std::move(it->second));
     else
       for (auto& e : sort)
@@ -213,17 +197,15 @@ DirectoryEnumerator::DirectoryEnumerator(const SystemChar* path, Mode mode,
     if (mode == Mode::DirsSorted)
       break;
     rewinddir(dir);
+    [[fallthrough]];
   }
-    case Mode::FilesSorted:
-    {
+  case Mode::FilesSorted: {
     if (mode == Mode::FilesSorted)
       m_entries.clear();
 
-        if (sizeSort)
-        {
+    if (sizeSort) {
       std::multimap<size_t, Entry> sort;
-            while ((d = readdir(dir)))
-            {
+      while ((d = readdir(dir))) {
         if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
           continue;
         if (noHidden && d->d_name[0] == '.')
@@ -234,22 +216,19 @@ DirectoryEnumerator::DirectoryEnumerator(const SystemChar* path, Mode mode,
         Sstat st;
         if (Stat(fp.c_str(), &st) || !S_ISREG(st.st_mode))
           continue;
-                sort.emplace(std::make_pair(st.st_size, Entry(std::move(fp), d->d_name, st.st_size, false)));
+        sort.emplace(std::make_pair(st.st_size, Entry(fp, d->d_name, st.st_size, false)));
       }
 
       m_entries.reserve(sort.size());
       if (reverse)
-                for (auto it=sort.crbegin() ; it != sort.crend() ; ++it)
+        for (auto it = sort.crbegin(); it != sort.crend(); ++it)
           m_entries.push_back(std::move(it->second));
       else
         for (auto& e : sort)
           m_entries.push_back(std::move(e.second));
-        }
-        else
-        {
+    } else {
       std::map<SystemString, Entry, CaseInsensitiveCompare> sort;
-            while ((d = readdir(dir)))
-            {
+      while ((d = readdir(dir))) {
         if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
           continue;
         if (noHidden && d->d_name[0] == '.')
@@ -260,12 +239,12 @@ DirectoryEnumerator::DirectoryEnumerator(const SystemChar* path, Mode mode,
         Sstat st;
         if (Stat(fp.c_str(), &st) || !S_ISREG(st.st_mode))
           continue;
-                sort.emplace(std::make_pair(d->d_name, Entry(std::move(fp), d->d_name, st.st_size, false)));
+        sort.emplace(std::make_pair(d->d_name, Entry(fp, d->d_name, st.st_size, false)));
       }
 
       m_entries.reserve(sort.size());
       if (reverse)
-                for (auto it=sort.crbegin() ; it != sort.crend() ; ++it)
+        for (auto it = sort.crbegin(); it != sort.crend(); ++it)
           m_entries.push_back(std::move(it->second));
       else
         for (auto& e : sort)
@@ -280,4 +259,4 @@ DirectoryEnumerator::DirectoryEnumerator(const SystemChar* path, Mode mode,
 #endif
 }
 
-}
+} // namespace nod

lib/DiscGCN.cpp

@@ -1,21 +1,27 @@
 #include "nod/DiscGCN.hpp"
+
+#include <cinttypes>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+
 #include "nod/nod.hpp"
-#include <inttypes.h>
+#include "nod/Util.hpp"
+
+#include <logvisor/logvisor.hpp>
+
 #define BUFFER_SZ 0x8000
 
-namespace nod
-{
+namespace nod {
 
-class PartitionGCN : public DiscBase::IPartition
-{
+class PartitionGCN : public IPartition {
 public:
   PartitionGCN(const DiscGCN& parent, uint64_t offset, bool& err)
-    : IPartition(parent, PartitionKind::Data, false, offset)
-    {
+  : IPartition(parent, PartitionKind::Data, false, offset) {
     /* GCN-specific header reads */
     std::unique_ptr<IPartReadStream> s = beginReadStream(0x0);
-        if (!s)
-        {
+    if (!s) {
       err = true;
       return;
     }
@@ -37,8 +43,7 @@ public:
     parseDOL(*s);
   }
 
-    class PartReadStream : public IPartReadStream
-    {
+  class PartReadStream : public IPartReadStream {
     const PartitionGCN& m_parent;
     std::unique_ptr<IReadStream> m_dio;
 
@@ -47,21 +52,17 @@ public:
     uint8_t m_buf[BUFFER_SZ];
 
   public:
-        PartReadStream(const PartitionGCN& parent, uint64_t offset, bool& err)
-        : m_parent(parent), m_offset(offset)
-        {
+    PartReadStream(const PartitionGCN& parent, uint64_t offset, bool& err) : m_parent(parent), m_offset(offset) {
       size_t block = m_offset / BUFFER_SZ;
       m_dio = m_parent.m_parent.getDiscIO().beginReadStream(block * BUFFER_SZ);
-            if (!m_dio)
-            {
+      if (!m_dio) {
         err = true;
         return;
       }
       m_dio->read(m_buf, BUFFER_SZ);
       m_curBlock = block;
     }
-        void seek(int64_t offset, int whence)
-        {
+    void seek(int64_t offset, int whence) override {
       if (whence == SEEK_SET)
         m_offset = offset;
       else if (whence == SEEK_CUR)
@@ -69,26 +70,22 @@ public:
       else
         return;
       size_t block = m_offset / BUFFER_SZ;
-            if (block != m_curBlock)
-            {
+      if (block != m_curBlock) {
         m_dio->seek(block * BUFFER_SZ);
         m_dio->read(m_buf, BUFFER_SZ);
         m_curBlock = block;
       }
     }
-        uint64_t position() const {return m_offset;}
-        uint64_t read(void* buf, uint64_t length)
-        {
+    uint64_t position() const override { return m_offset; }
+    uint64_t read(void* buf, uint64_t length) override {
       size_t block = m_offset / BUFFER_SZ;
       size_t cacheOffset = m_offset % BUFFER_SZ;
       uint64_t cacheSize;
       uint64_t rem = length;
       uint8_t* dst = (uint8_t*)buf;
 
-            while (rem)
-            {
-                if (block != m_curBlock)
-                {
+      while (rem) {
+        if (block != m_curBlock) {
           m_dio->read(m_buf, BUFFER_SZ);
           m_curBlock = block;
         }
@@ -109,65 +106,56 @@ public:
     }
   };
 
-    std::unique_ptr<IPartReadStream> beginReadStream(uint64_t offset) const
-    {
-        bool Err = false;
-        auto ret = std::unique_ptr<IPartReadStream>(new PartReadStream(*this, offset, Err));
-        if (Err)
-            return {};
+  std::unique_ptr<IPartReadStream> beginReadStream(uint64_t offset) const override {
+    bool err = false;
+    auto ret = std::make_unique<PartReadStream>(*this, offset, err);
+
+    if (err) {
+      return nullptr;
+    }
+
     return ret;
   }
 };
 
-DiscGCN::DiscGCN(std::unique_ptr<IDiscIO>&& dio, bool& err)
-: DiscBase(std::move(dio), err)
-{
+DiscGCN::DiscGCN(std::unique_ptr<IDiscIO>&& dio, bool& err) : DiscBase(std::move(dio), err) {
   if (err)
     return;
 
   /* One lone partition for GCN */
-    m_partitions.emplace_back(new PartitionGCN(*this, 0, err));
+  m_partitions.emplace_back(std::make_unique<PartitionGCN>(*this, 0, err));
 }
 
-DiscBuilderGCN DiscGCN::makeMergeBuilder(const SystemChar* outPath, FProgress progressCB)
-{
+DiscBuilderGCN DiscGCN::makeMergeBuilder(SystemStringView outPath, FProgress progressCB) {
   return DiscBuilderGCN(outPath, progressCB);
 }
 
-bool DiscGCN::extractDiscHeaderFiles(const SystemString& path, const ExtractionContext& ctx) const
-{
-    return true;
-}
+bool DiscGCN::extractDiscHeaderFiles(SystemStringView path, const ExtractionContext& ctx) const { return true; }
 
-class PartitionBuilderGCN : public DiscBuilderBase::PartitionBuilderBase
-{
+class PartitionBuilderGCN : public DiscBuilderBase::PartitionBuilderBase {
   uint64_t m_curUser = 0x57058000;
 
 public:
-    class PartWriteStream : public IPartWriteStream
-    {
+  class PartWriteStream : public IPartWriteStream {
     const PartitionBuilderGCN& m_parent;
     uint64_t m_offset;
     std::unique_ptr<IFileIO::IWriteStream> m_fio;
 
   public:
     PartWriteStream(const PartitionBuilderGCN& parent, uint64_t offset, bool& err)
-        : m_parent(parent), m_offset(offset)
-        {
+    : m_parent(parent), m_offset(offset) {
       m_fio = m_parent.m_parent.getFileIO().beginWriteStream(offset);
       if (!m_fio)
         err = true;
     }
-        void close() {m_fio.reset();}
-        uint64_t position() const {return m_offset;}
-        uint64_t write(const void* buf, uint64_t length)
-        {
+    void close() override { m_fio.reset(); }
+    uint64_t position() const override { return m_offset; }
+    uint64_t write(const void* buf, uint64_t length) override {
       uint64_t len = m_fio->write(buf, length);
       m_offset += len;
       return len;
     }
-        void seek(size_t off)
-        {
+    void seek(size_t off) {
       m_offset = off;
       m_fio = m_parent.m_parent.getFileIO().beginWriteStream(off);
     }
@@ -176,38 +164,34 @@ public:
   PartitionBuilderGCN(DiscBuilderBase& parent)
   : DiscBuilderBase::PartitionBuilderBase(parent, PartitionKind::Data, false) {}
 
-    uint64_t userAllocate(uint64_t reqSz, IPartWriteStream& ws)
-    {
+  uint64_t userAllocate(uint64_t reqSz, IPartWriteStream& ws) override {
     m_curUser -= reqSz;
     m_curUser &= 0xfffffffffffffff0;
-        if (m_curUser < 0x30000)
-        {
-            LogModule.report(logvisor::Error, "user area low mark reached");
+    if (m_curUser < 0x30000) {
+      LogModule.report(logvisor::Error, fmt("user area low mark reached"));
       return -1;
     }
     static_cast<PartWriteStream&>(ws).seek(m_curUser);
     return m_curUser;
   }
 
-    uint32_t packOffset(uint64_t offset) const
-    {
-        return offset;
+  uint32_t packOffset(uint64_t offset) const override { return offset; }
+
+  std::unique_ptr<IPartWriteStream> beginWriteStream(uint64_t offset) override {
+    bool err = false;
+    auto ret = std::make_unique<PartWriteStream>(*this, offset, err);
+
+    if (err) {
+      return nullptr;
     }
 
-    std::unique_ptr<IPartWriteStream> beginWriteStream(uint64_t offset)
-    {
-        bool Err = false;
-        std::unique_ptr<IPartWriteStream> ret = std::make_unique<PartWriteStream>(*this, offset, Err);
-        if (Err)
-            return {};
     return ret;
   }
 
-    bool _build(const std::function<bool(IPartWriteStream&, uint32_t, uint32_t,
-                                         uint32_t, uint32_t, uint32_t)>& headerFunc,
+  bool
+  _build(const std::function<bool(IPartWriteStream&, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t)>& headerFunc,
          const std::function<bool(IPartWriteStream&)>& bi2Func,
-                const std::function<bool(IPartWriteStream&, size_t&)>& apploaderFunc)
-    {
+         const std::function<bool(IPartWriteStream&, size_t&)>& apploaderFunc) {
     std::unique_ptr<IPartWriteStream> ws = beginWriteStream(0x2440);
     if (!ws)
       return false;
@@ -217,19 +201,17 @@ public:
 
     size_t fstOff = ROUND_UP_32(xferSz);
     size_t fstSz = sizeof(FSTNode) * m_buildNodes.size();
-        for (size_t i=0 ; i<fstOff-xferSz ; ++i)
+    for (size_t i = 0; i < fstOff - xferSz; ++i)
       ws->write("\xff", 1);
     fstOff += 0x2440;
     ws->write(m_buildNodes.data(), fstSz);
     for (const std::string& str : m_buildNames)
-            ws->write(str.data(), str.size()+1);
+      ws->write(str.data(), str.size() + 1);
     fstSz += m_buildNameOff;
     fstSz = ROUND_UP_32(fstSz);
 
-        if (fstOff + fstSz >= m_curUser)
-        {
-            LogModule.report(logvisor::Error,
-                             "FST flows into user area (one or the other is too big)");
+    if (fstOff + fstSz >= m_curUser) {
+      LogModule.report(logvisor::Error, fmt("FST flows into user area (one or the other is too big)"));
       return false;
     }
 
@@ -244,8 +226,7 @@ public:
     return true;
   }
 
-    bool buildFromDirectory(const SystemChar* dirIn)
-    {
+  bool buildFromDirectory(SystemStringView dirIn) {
     std::unique_ptr<IPartWriteStream> ws = beginWriteStream(0);
     if (!ws)
       return false;
@@ -256,36 +237,32 @@ public:
     SystemString dirStr(dirIn);
 
     /* Check Apploader */
-        SystemString apploaderIn = dirStr + _S("/sys/apploader.img");
+    SystemString apploaderIn = dirStr + _SYS_STR("/sys/apploader.img");
     Sstat apploaderStat;
-        if (Stat(apploaderIn.c_str(), &apploaderStat))
-        {
-            LogModule.report(logvisor::Error, _S("unable to stat %s"), apploaderIn.c_str());
-            return -1;
+    if (Stat(apploaderIn.c_str(), &apploaderStat)) {
+      LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {}")), apploaderIn);
+      return false;
     }
 
     /* Check Boot */
-        SystemString bootIn = dirStr + _S("/sys/boot.bin");
+    SystemString bootIn = dirStr + _SYS_STR("/sys/boot.bin");
     Sstat bootStat;
-        if (Stat(bootIn.c_str(), &bootStat))
-        {
-            LogModule.report(logvisor::Error, _S("unable to stat %s"), bootIn.c_str());
-            return -1;
+    if (Stat(bootIn.c_str(), &bootStat)) {
+      LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {}")), bootIn);
+      return false;
     }
 
     /* Check BI2 */
-        SystemString bi2In = dirStr + _S("/sys/bi2.bin");
+    SystemString bi2In = dirStr + _SYS_STR("/sys/bi2.bin");
     Sstat bi2Stat;
-        if (Stat(bi2In.c_str(), &bi2Stat))
-        {
-            LogModule.report(logvisor::Error, _S("unable to stat %s"), bi2In.c_str());
-            return -1;
+    if (Stat(bi2In.c_str(), &bi2Stat)) {
+      LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {}")), bi2In);
+      return false;
     }
 
     return _build(
-        [this, &bootIn](IPartWriteStream& ws, uint32_t dolOff, uint32_t fstOff, uint32_t fstSz,
-                        uint32_t userOff, uint32_t userSz) -> bool
-        {
+        [&bootIn](IPartWriteStream& ws, uint32_t dolOff, uint32_t fstOff, uint32_t fstSz, uint32_t userOff,
+                  uint32_t userSz) -> bool {
           std::unique_ptr<IFileIO::IReadStream> rs = NewFileIO(bootIn.c_str())->beginReadStream();
           if (!rs)
             return false;
@@ -300,8 +277,7 @@ public:
           header.write(ws);
           return true;
         },
-        [this, &bi2In](IPartWriteStream& ws) -> bool
-        {
+        [&bi2In](IPartWriteStream& ws) -> bool {
           std::unique_ptr<IFileIO::IReadStream> rs = NewFileIO(bi2In.c_str())->beginReadStream();
           if (!rs)
             return false;
@@ -310,23 +286,19 @@ public:
           bi2.write(ws);
           return true;
         },
-        [this, &apploaderIn](IPartWriteStream& ws, size_t& xferSz) -> bool
-        {
+        [this, &apploaderIn](IPartWriteStream& ws, size_t& xferSz) -> bool {
           std::unique_ptr<IFileIO::IReadStream> rs = NewFileIO(apploaderIn.c_str())->beginReadStream();
           if (!rs)
             return false;
           char buf[8192];
-            while (true)
-            {
+          while (true) {
             size_t rdSz = rs->read(buf, 8192);
             if (!rdSz)
               break;
             ws.write(buf, rdSz);
             xferSz += rdSz;
-                if (0x2440 + xferSz >= m_curUser)
-                {
-                    LogModule.report(logvisor::Error,
-                                     "apploader flows into user area (one or the other is too big)");
+            if (0x2440 + xferSz >= m_curUser) {
+              LogModule.report(logvisor::Error, fmt("apploader flows into user area (one or the other is too big)"));
               return false;
             }
             m_parent.m_progressCB(m_parent.getProgressFactor(), apploaderIn, xferSz);
@@ -336,8 +308,7 @@ public:
         });
   }
 
-    bool mergeFromDirectory(const PartitionGCN* partIn, const SystemChar* dirIn)
-    {
+  bool mergeFromDirectory(const PartitionGCN* partIn, SystemStringView dirIn) {
     std::unique_ptr<IPartWriteStream> ws = beginWriteStream(0);
     if (!ws)
       return false;
@@ -346,9 +317,8 @@ public:
       return false;
 
     return _build(
-        [this, partIn](IPartWriteStream& ws, uint32_t dolOff, uint32_t fstOff, uint32_t fstSz,
-                       uint32_t userOff, uint32_t userSz) -> bool
-        {
+        [partIn](IPartWriteStream& ws, uint32_t dolOff, uint32_t fstOff, uint32_t fstSz, uint32_t userOff,
+                 uint32_t userSz) -> bool {
           Header header = partIn->getHeader();
           header.m_dolOff = dolOff;
           header.m_fstOff = fstOff;
@@ -359,22 +329,18 @@ public:
           header.write(ws);
           return true;
         },
-        [this, partIn](IPartWriteStream& ws) -> bool
-        {
+        [partIn](IPartWriteStream& ws) -> bool {
           partIn->getBI2().write(ws);
           return true;
         },
-        [this, partIn](IPartWriteStream& ws, size_t& xferSz) -> bool
-        {
+        [this, partIn](IPartWriteStream& ws, size_t& xferSz) -> bool {
           std::unique_ptr<uint8_t[]> apploaderBuf = partIn->getApploaderBuf();
           size_t apploaderSz = partIn->getApploaderSize();
-            SystemString apploaderName(_S("<apploader>"));
+          SystemString apploaderName(_SYS_STR("<apploader>"));
           ws.write(apploaderBuf.get(), apploaderSz);
           xferSz += apploaderSz;
-            if (0x2440 + xferSz >= m_curUser)
-            {
-                LogModule.report(logvisor::Error,
-                                 "apploader flows into user area (one or the other is too big)");
+          if (0x2440 + xferSz >= m_curUser) {
+            LogModule.report(logvisor::Error, fmt("apploader flows into user area (one or the other is too big)"));
             return false;
           }
           m_parent.m_progressCB(m_parent.getProgressFactor(), apploaderName, xferSz);
@@ -384,85 +350,82 @@ public:
   }
 };
 
-EBuildResult DiscBuilderGCN::buildFromDirectory(const SystemChar* dirIn)
-{
+EBuildResult DiscBuilderGCN::buildFromDirectory(SystemStringView dirIn) {
   if (!m_fileIO->beginWriteStream())
     return EBuildResult::Failed;
-    if (!CheckFreeSpace(m_outPath.c_str(), 0x57058000))
-    {
-        LogModule.report(logvisor::Error, _S("not enough free disk space for %s"), m_outPath.c_str());
+  if (!CheckFreeSpace(m_outPath.c_str(), 0x57058000)) {
+    LogModule.report(logvisor::Error, fmt(_SYS_STR("not enough free disk space for {}")), m_outPath);
     return EBuildResult::DiskFull;
   }
-    m_progressCB(getProgressFactor(), _S("Preallocating image"), -1);
+  m_progressCB(getProgressFactor(), _SYS_STR("Preallocating image"), -1);
   ++m_progressIdx;
-    auto ws = m_fileIO->beginWriteStream(0x57058000 - 1);
+  {
+    auto ws = m_fileIO->beginWriteStream(0);
     if (!ws)
       return EBuildResult::Failed;
-    ws->write("", 1);
+    char zeroBytes[1024] = {};
+    for (uint64_t i = 0; i < 0x57058000; i += 1024)
+      ws->write(zeroBytes, 1024);
+  }
 
   PartitionBuilderGCN& pb = static_cast<PartitionBuilderGCN&>(*m_partitions[0]);
   return pb.buildFromDirectory(dirIn) ? EBuildResult::Success : EBuildResult::Failed;
 }
 
-uint64_t DiscBuilderGCN::CalculateTotalSizeRequired(const SystemChar* dirIn)
-{
+uint64_t DiscBuilderGCN::CalculateTotalSizeRequired(SystemStringView dirIn) {
   uint64_t sz = DiscBuilderBase::PartitionBuilderBase::CalculateTotalSizeBuild(dirIn, PartitionKind::Data, false);
-    if (sz == -1)
-        return -1;
+  if (sz == UINT64_MAX)
+    return UINT64_MAX;
   sz += 0x30000;
-    if (sz > 0x57058000)
-    {
-        LogModule.report(logvisor::Error, _S("disc capacity exceeded [%" PRIu64 " / %" PRIu64 "]"), sz, 0x57058000);
-        return -1;
+  if (sz > 0x57058000) {
+    LogModule.report(logvisor::Error, fmt(_SYS_STR("disc capacity exceeded [{} / {}]")), sz, 0x57058000);
+    return UINT64_MAX;
   }
   return sz;
 }
 
-DiscBuilderGCN::DiscBuilderGCN(const SystemChar* outPath, FProgress progressCB)
-: DiscBuilderBase(outPath, 0x57058000, progressCB)
-{
-    PartitionBuilderGCN* partBuilder = new PartitionBuilderGCN(*this);
-    m_partitions.emplace_back(partBuilder);
+DiscBuilderGCN::DiscBuilderGCN(SystemStringView outPath, FProgress progressCB)
+: DiscBuilderBase(outPath, 0x57058000, progressCB) {
+  m_partitions.emplace_back(std::make_unique<PartitionBuilderGCN>(*this));
 }
 
-DiscMergerGCN::DiscMergerGCN(const SystemChar* outPath, DiscGCN& sourceDisc, FProgress progressCB)
-: m_sourceDisc(sourceDisc), m_builder(sourceDisc.makeMergeBuilder(outPath, progressCB))
-{}
+DiscMergerGCN::DiscMergerGCN(SystemStringView outPath, DiscGCN& sourceDisc, FProgress progressCB)
+: m_sourceDisc(sourceDisc), m_builder(sourceDisc.makeMergeBuilder(outPath, progressCB)) {}
 
-EBuildResult DiscMergerGCN::mergeFromDirectory(const SystemChar* dirIn)
-{
+EBuildResult DiscMergerGCN::mergeFromDirectory(SystemStringView dirIn) {
   if (!m_builder.getFileIO().beginWriteStream())
     return EBuildResult::Failed;
-    if (!CheckFreeSpace(m_builder.m_outPath.c_str(), 0x57058000))
-    {
-        LogModule.report(logvisor::Error, _S("not enough free disk space for %s"), m_builder.m_outPath.c_str());
+  if (!CheckFreeSpace(m_builder.m_outPath.c_str(), 0x57058000)) {
+    LogModule.report(logvisor::Error, fmt(_SYS_STR("not enough free disk space for {}")), m_builder.m_outPath);
     return EBuildResult::DiskFull;
   }
-    m_builder.m_progressCB(m_builder.getProgressFactor(), _S("Preallocating image"), -1);
+  m_builder.m_progressCB(m_builder.getProgressFactor(), _SYS_STR("Preallocating image"), -1);
   ++m_builder.m_progressIdx;
-    auto ws = m_builder.m_fileIO->beginWriteStream(0x57058000 - 1);
+  {
+    auto ws = m_builder.m_fileIO->beginWriteStream(0);
     if (!ws)
       return EBuildResult::Failed;
-    ws->write("", 1);
+    char zeroBytes[1024] = {};
+    for (uint64_t i = 0; i < 0x57058000; i += 1024)
+      ws->write(zeroBytes, 1024);
+  }
 
   PartitionBuilderGCN& pb = static_cast<PartitionBuilderGCN&>(*m_builder.m_partitions[0]);
-    return pb.mergeFromDirectory(static_cast<PartitionGCN*>(m_sourceDisc.getDataPartition()), dirIn) ?
-           EBuildResult::Success : EBuildResult::Failed;
+  return pb.mergeFromDirectory(static_cast<PartitionGCN*>(m_sourceDisc.getDataPartition()), dirIn)
+             ? EBuildResult::Success
+             : EBuildResult::Failed;
 }
 
-uint64_t DiscMergerGCN::CalculateTotalSizeRequired(DiscGCN& sourceDisc, const SystemChar* dirIn)
-{
-    uint64_t sz = DiscBuilderBase::PartitionBuilderBase::CalculateTotalSizeMerge(
-                  sourceDisc.getDataPartition(), dirIn);
-    if (sz == -1)
-        return -1;
+uint64_t DiscMergerGCN::CalculateTotalSizeRequired(DiscGCN& sourceDisc, SystemStringView dirIn) {
+  uint64_t sz = DiscBuilderBase::PartitionBuilderBase::CalculateTotalSizeMerge(sourceDisc.getDataPartition(), dirIn);
+  if (sz == UINT64_MAX)
+    return UINT64_MAX;
   sz += 0x30000;
-    if (sz > 0x57058000)
-    {
-        LogModule.report(logvisor::Error, _S("disc capacity exceeded [%" PRIu64 " / %" PRIu64 "]"), sz, 0x57058000);
+  if (sz > 0x57058000) {
+    LogModule.report(logvisor::Error, fmt(_SYS_STR("disc capacity exceeded [{} / {}]")), sz, 0x57058000);
     return -1;
   }
   return sz;
 }
 
-}
+} // namespace nod

lib/DiscIOISO.cpp

@@ -1,69 +1,64 @@
-#include <stdio.h>
-#include "nod/Util.hpp"
 #include "nod/IDiscIO.hpp"
 #include "nod/IFileIO.hpp"
+#include "nod/Util.hpp"
 
-namespace nod
-{
+namespace nod {
 
-class DiscIOISO : public IDiscIO
-{
+class DiscIOISO : public IDiscIO {
   std::unique_ptr<IFileIO> m_fio;
-public:
-    DiscIOISO(const SystemString& fpin)
-    : m_fio(NewFileIO(fpin)) {}
 
-    class ReadStream : public IReadStream
-    {
+public:
+  DiscIOISO(SystemStringView fpin) : m_fio(NewFileIO(fpin)) {}
+
+  class ReadStream : public IReadStream {
     friend class DiscIOISO;
     std::unique_ptr<IFileIO::IReadStream> fp;
-        ReadStream(std::unique_ptr<IFileIO::IReadStream>&& fpin, bool& err)
-        : fp(std::move(fpin)) { if (!fp) err = true; }
+    ReadStream(std::unique_ptr<IFileIO::IReadStream>&& fpin, bool& err) : fp(std::move(fpin)) {
+      if (!fp)
+        err = true;
+    }
+
   public:
-        uint64_t read(void* buf, uint64_t length)
-        {return fp->read(buf, length);}
-        uint64_t position() const
-        {return fp->position();}
-        void seek(int64_t offset, int whence)
-        {fp->seek(offset, whence);}
+    uint64_t read(void* buf, uint64_t length) override { return fp->read(buf, length); }
+    uint64_t position() const override { return fp->position(); }
+    void seek(int64_t offset, int whence) override { fp->seek(offset, whence); }
   };
 
-    std::unique_ptr<IReadStream> beginReadStream(uint64_t offset) const
-    {
-        bool Err = false;
-        auto ret = std::unique_ptr<IReadStream>(new ReadStream(m_fio->beginReadStream(offset), Err));
-        if (Err)
-            return {};
+  std::unique_ptr<IReadStream> beginReadStream(uint64_t offset) const override {
+    bool err = false;
+    auto ret = std::unique_ptr<IReadStream>(new ReadStream(m_fio->beginReadStream(offset), err));
+
+    if (err) {
+      return nullptr;
+    }
+
     return ret;
   }
 
-    class WriteStream : public IWriteStream
-    {
+  class WriteStream : public IWriteStream {
     friend class DiscIOISO;
     std::unique_ptr<IFileIO::IWriteStream> fp;
-        WriteStream(std::unique_ptr<IFileIO::IWriteStream>&& fpin, bool& err)
-        : fp(std::move(fpin)) { if (!fp) err = true; }
-    public:
-        uint64_t write(const void* buf, uint64_t length)
-        {
-            return fp->write(buf, length);
+    WriteStream(std::unique_ptr<IFileIO::IWriteStream>&& fpin, bool& err) : fp(std::move(fpin)) {
+      if (!fp)
+        err = true;
     }
+
+  public:
+    uint64_t write(const void* buf, uint64_t length) override { return fp->write(buf, length); }
   };
 
-    std::unique_ptr<IWriteStream> beginWriteStream(uint64_t offset) const
-    {
-        bool Err = false;
-        auto ret = std::unique_ptr<IWriteStream>(new WriteStream(m_fio->beginWriteStream(offset), Err));
-        if (Err)
-            return {};
+  std::unique_ptr<IWriteStream> beginWriteStream(uint64_t offset) const override {
+    bool err = false;
+    auto ret = std::unique_ptr<IWriteStream>(new WriteStream(m_fio->beginWriteStream(offset), err));
+
+    if (err) {
+      return nullptr;
+    }
+
     return ret;
   }
 };
 
-std::unique_ptr<IDiscIO> NewDiscIOISO(const SystemChar* path)
-{
-    return std::unique_ptr<IDiscIO>(new DiscIOISO(path));
-}
-
-}
+std::unique_ptr<IDiscIO> NewDiscIOISO(SystemStringView path) { return std::make_unique<DiscIOISO>(path); }
 
+} // namespace nod

lib/DiscIOWBFS.cpp

@@ -1,31 +1,31 @@
-#include <stdio.h>
-#include <inttypes.h>
-#include "nod/Util.hpp"
+#include <cinttypes>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+
 #include "nod/IDiscIO.hpp"
 #include "nod/IFileIO.hpp"
+#include "nod/Util.hpp"
 
-namespace nod
-{
+#include <logvisor/logvisor.hpp>
 
-#define ALIGN_LBA(x) (((x)+p->hd_sec_sz-1)&(~(p->hd_sec_sz-1)))
+namespace nod {
 
-static uint8_t size_to_shift(uint32_t size)
-{
+#define ALIGN_LBA(x) (((x) + p->hd_sec_sz - 1) & (~(p->hd_sec_sz - 1)))
+
+static uint8_t size_to_shift(uint32_t size) {
   uint8_t ret = 0;
-    while (size)
-    {
+  while (size) {
     ret++;
-        size>>=1;
+    size >>= 1;
   }
-    return ret-1;
+  return ret - 1;
 }
 
-class DiscIOWBFS : public IDiscIO
-{
+class DiscIOWBFS : public IDiscIO {
   SystemString filepath;
 
-    struct WBFSHead
-    {
+  struct WBFSHead {
     uint32_t magic;
     // parameters copied in the partition for easy dumping, and bug reports
     uint32_t n_hd_sec;     // total number of hd_sec in this partition
@@ -36,15 +36,13 @@ class DiscIOWBFS : public IDiscIO
   };
   std::unique_ptr<uint8_t[]> wbfsHead;
 
-    struct WBFSDiscInfo
-    {
+  struct WBFSDiscInfo {
     uint8_t disc_header_copy[0x100];
     uint16_t wlba_table[0];
   };
   std::unique_ptr<uint8_t[]> wbfsDiscInfo;
 
-    struct WBFS
-    {
+  struct WBFS {
     /* hdsectors, the size of the sector provided by the hosting hard drive */
     uint32_t hd_sec_sz;
     uint8_t hd_sec_sz_s; // the power of two of the last number
@@ -66,30 +64,26 @@ class DiscIOWBFS : public IDiscIO
 
     uint16_t max_disc;
     uint32_t freeblks_lba;
-        uint32_t *freeblks;
+    uint32_t* freeblks;
     uint16_t disc_info_sz;
 
     uint32_t n_disc_open;
 
   } wbfs;
 
-    static int _wbfsReadSector(IFileIO::IReadStream& rs, uint32_t lba, uint32_t count, void* buf)
-    {
+  static int _wbfsReadSector(IFileIO::IReadStream& rs, uint32_t lba, uint32_t count, void* buf) {
     uint64_t off = lba;
-        off*=512ULL;
+    off *= 512ULL;
     rs.seek(off, SEEK_SET);
-        if (rs.read(buf, count*512ULL) != count*512ULL)
-        {
-            LogModule.report(logvisor::Error, "error reading disc");
+    if (rs.read(buf, count * 512ULL) != count * 512ULL) {
+      LogModule.report(logvisor::Error, fmt("error reading disc"));
       return 1;
     }
     return 0;
   }
 
 public:
-    DiscIOWBFS(const SystemString& fpin)
-    : filepath(fpin)
-    {
+  DiscIOWBFS(SystemStringView fpin) : filepath(fpin) {
     /* Temporary file handle to read LBA table */
     std::unique_ptr<IFileIO> fio = NewFileIO(filepath);
     std::unique_ptr<IFileIO::IReadStream> rs = fio->beginReadStream();
@@ -99,7 +93,7 @@ public:
     WBFS* p = &wbfs;
     WBFSHead tmpHead;
     if (rs->read(&tmpHead, sizeof(tmpHead)) != sizeof(tmpHead)) {
-            LogModule.report(logvisor::Error, "unable to read WBFS head");
+      LogModule.report(logvisor::Error, fmt("unable to read WBFS head"));
       return;
     }
     unsigned hd_sector_size = 1 << tmpHead.hd_sec_sz_s;
@@ -109,65 +103,63 @@ public:
     WBFSHead* head = (WBFSHead*)wbfsHead.get();
     rs->seek(0, SEEK_SET);
     if (rs->read(head, hd_sector_size) != hd_sector_size) {
-            LogModule.report(logvisor::Error, "unable to read WBFS head");
+      LogModule.report(logvisor::Error, fmt("unable to read WBFS head"));
       return;
     }
 
-        //constants, but put here for consistancy
+    // constants, but put here for consistancy
     p->wii_sec_sz = 0x8000;
     p->wii_sec_sz_s = size_to_shift(0x8000);
-        p->n_wii_sec = (num_hd_sector/0x8000)*hd_sector_size;
-        p->n_wii_sec_per_disc = 143432*2;//support for double layers discs..
+    p->n_wii_sec = (num_hd_sector / 0x8000) * hd_sector_size;
+    p->n_wii_sec_per_disc = 143432 * 2; // support for double layers discs..
     p->part_lba = 0;
     if (_wbfsReadSector(*rs, p->part_lba, 1, head))
       return;
     if (hd_sector_size && head->hd_sec_sz_s != size_to_shift(hd_sector_size)) {
-            LogModule.report(logvisor::Error, "hd sector size doesn't match");
+      LogModule.report(logvisor::Error, fmt("hd sector size doesn't match"));
       return;
     }
     if (num_hd_sector && head->n_hd_sec != SBig(num_hd_sector)) {
-            LogModule.report(logvisor::Error, "hd num sector doesn't match");
+      LogModule.report(logvisor::Error, fmt("hd num sector doesn't match"));
       return;
     }
-        p->hd_sec_sz = 1<<head->hd_sec_sz_s;
+    p->hd_sec_sz = 1 << head->hd_sec_sz_s;
     p->hd_sec_sz_s = head->hd_sec_sz_s;
     p->n_hd_sec = SBig(head->n_hd_sec);
 
-        p->n_wii_sec = (p->n_hd_sec/p->wii_sec_sz)*(p->hd_sec_sz);
+    p->n_wii_sec = (p->n_hd_sec / p->wii_sec_sz) * (p->hd_sec_sz);
 
     p->wbfs_sec_sz_s = head->wbfs_sec_sz_s;
-        p->wbfs_sec_sz = 1<<p->wbfs_sec_sz_s;
+    p->wbfs_sec_sz = 1 << p->wbfs_sec_sz_s;
     p->n_wbfs_sec = p->n_wii_sec >> (p->wbfs_sec_sz_s - p->wii_sec_sz_s);
     p->n_wbfs_sec_per_disc = p->n_wii_sec_per_disc >> (p->wbfs_sec_sz_s - p->wii_sec_sz_s);
-        p->disc_info_sz = ALIGN_LBA(uint16_t(sizeof(WBFSDiscInfo)) + p->n_wbfs_sec_per_disc*2);
+    p->disc_info_sz = ALIGN_LBA(uint16_t(sizeof(WBFSDiscInfo)) + p->n_wbfs_sec_per_disc * 2);
 
-        p->freeblks_lba = (p->wbfs_sec_sz - p->n_wbfs_sec/8)>>p->hd_sec_sz_s;
+    p->freeblks_lba = (p->wbfs_sec_sz - p->n_wbfs_sec / 8) >> p->hd_sec_sz_s;
 
     p->freeblks = 0; // will alloc and read only if needed
-        p->max_disc = (p->freeblks_lba-1)/(p->disc_info_sz>>p->hd_sec_sz_s);
-        if(p->max_disc > p->hd_sec_sz - sizeof(WBFSHead))
+    p->max_disc = (p->freeblks_lba - 1) / (p->disc_info_sz >> p->hd_sec_sz_s);
+    if (p->max_disc > p->hd_sec_sz - sizeof(WBFSHead))
       p->max_disc = p->hd_sec_sz - sizeof(WBFSHead);
 
     p->n_disc_open = 0;
 
-        int disc_info_sz_lba = p->disc_info_sz>>p->hd_sec_sz_s;
-        if (head->disc_table[0])
-        {
+    int disc_info_sz_lba = p->disc_info_sz >> p->hd_sec_sz_s;
+    if (head->disc_table[0]) {
       wbfsDiscInfo.reset(new uint8_t[p->disc_info_sz]);
       if (!wbfsDiscInfo) {
-                LogModule.report(logvisor::Error, "allocating memory");
+        LogModule.report(logvisor::Error, fmt("allocating memory"));
         return;
       }
-            if (_wbfsReadSector(*rs, p->part_lba+1, disc_info_sz_lba, wbfsDiscInfo.get()))
+      if (_wbfsReadSector(*rs, p->part_lba + 1, disc_info_sz_lba, wbfsDiscInfo.get()))
         return;
       p->n_disc_open++;
-            //for(i=0;i<p->n_wbfs_sec_per_disc;i++)
+      // for(i=0;i<p->n_wbfs_sec_per_disc;i++)
       //    printf("%d,",wbfs_ntohs(d->header->wlba_table[i]));
     }
   }
 
-    class ReadStream : public IReadStream
-    {
+  class ReadStream : public IReadStream {
     friend class DiscIOWBFS;
     const DiscIOWBFS& m_parent;
     std::unique_ptr<IFileIO::IReadStream> fp;
@@ -175,33 +167,32 @@ public:
     std::unique_ptr<uint8_t[]> m_tmpBuffer;
 
     ReadStream(const DiscIOWBFS& parent, std::unique_ptr<IFileIO::IReadStream>&& fpin, uint64_t offset, bool& err)
-        : m_parent(parent),
-          fp(std::move(fpin)),
-          m_offset(offset),
-          m_tmpBuffer(new uint8_t[parent.wbfs.hd_sec_sz]) { if (!fp) err = true; }
+    : m_parent(parent), fp(std::move(fpin)), m_offset(offset), m_tmpBuffer(new uint8_t[parent.wbfs.hd_sec_sz]) {
+      if (!fp)
+        err = true;
+    }
 
-        int wbfsReadSector(uint32_t lba, uint32_t count, void* buf)
-        {return DiscIOWBFS::_wbfsReadSector(*fp, lba, count, buf);}
+    int wbfsReadSector(uint32_t lba, uint32_t count, void* buf) {
+      return DiscIOWBFS::_wbfsReadSector(*fp, lba, count, buf);
+    }
 
-        int wbfsDiscRead(uint32_t offset, uint8_t *data, uint64_t len)
-        {
+    int wbfsDiscRead(uint32_t offset, uint8_t* data, uint64_t len) {
       const WBFS* p = &m_parent.wbfs;
       const WBFSDiscInfo* d = (WBFSDiscInfo*)m_parent.wbfsDiscInfo.get();
-            uint16_t wlba = offset>>(p->wbfs_sec_sz_s-2);
+      uint16_t wlba = offset >> (p->wbfs_sec_sz_s - 2);
       uint32_t iwlba_shift = p->wbfs_sec_sz_s - p->hd_sec_sz_s;
-            uint32_t lba_mask = (p->wbfs_sec_sz-1)>>(p->hd_sec_sz_s);
-            uint64_t lba = (offset>>(p->hd_sec_sz_s-2))&lba_mask;
-            uint64_t off = offset&((p->hd_sec_sz>>2)-1);
+      uint32_t lba_mask = (p->wbfs_sec_sz - 1) >> (p->hd_sec_sz_s);
+      uint64_t lba = (offset >> (p->hd_sec_sz_s - 2)) & lba_mask;
+      uint64_t off = offset & ((p->hd_sec_sz >> 2) - 1);
       uint16_t iwlba = SBig(d->wlba_table[wlba]);
       uint64_t len_copied;
       int err = 0;
-            uint8_t  *ptr = data;
+      uint8_t* ptr = data;
       if (!iwlba)
         return 1;
-            if (off)
-            {
-                off*=4;
-                err = wbfsReadSector(p->part_lba + (iwlba<<iwlba_shift) + lba, 1, m_tmpBuffer.get());
+      if (off) {
+        off *= 4;
+        err = wbfsReadSector(p->part_lba + (iwlba << iwlba_shift) + lba, 1, m_tmpBuffer.get());
         if (err)
           return err;
         len_copied = p->hd_sec_sz - off;
@@ -211,37 +202,33 @@ public:
         len -= len_copied;
         ptr += len_copied;
         lba++;
-                if (lba>lba_mask && len)
-                {
-                    lba=0;
-                    iwlba = SBig(d->wlba_table[++wlba]);
-                    if (!iwlba)
-                        return 1;
-                }
-            }
-            while (len>=p->hd_sec_sz)
-            {
-                uint32_t nlb = len>>(p->hd_sec_sz_s);
-
-                if (lba + nlb > p->wbfs_sec_sz) // dont cross wbfs sectors..
-                    nlb = p->wbfs_sec_sz-lba;
-                err = wbfsReadSector(p->part_lba + (iwlba<<iwlba_shift) + lba, nlb, ptr);
-                if (err)
-                    return err;
-                len -= nlb<<p->hd_sec_sz_s;
-                ptr += nlb<<p->hd_sec_sz_s;
-                lba += nlb;
-                if (lba>lba_mask && len)
-                {
+        if (lba > lba_mask && len) {
           lba = 0;
           iwlba = SBig(d->wlba_table[++wlba]);
           if (!iwlba)
             return 1;
         }
       }
-            if (len)
-            {
-                err = wbfsReadSector(p->part_lba + (iwlba<<iwlba_shift) + lba, 1, m_tmpBuffer.get());
+      while (len >= p->hd_sec_sz) {
+        uint32_t nlb = len >> (p->hd_sec_sz_s);
+
+        if (lba + nlb > p->wbfs_sec_sz) // dont cross wbfs sectors..
+          nlb = p->wbfs_sec_sz - lba;
+        err = wbfsReadSector(p->part_lba + (iwlba << iwlba_shift) + lba, nlb, ptr);
+        if (err)
+          return err;
+        len -= nlb << p->hd_sec_sz_s;
+        ptr += nlb << p->hd_sec_sz_s;
+        lba += nlb;
+        if (lba > lba_mask && len) {
+          lba = 0;
+          iwlba = SBig(d->wlba_table[++wlba]);
+          if (!iwlba)
+            return 1;
+        }
+      }
+      if (len) {
+        err = wbfsReadSector(p->part_lba + (iwlba << iwlba_shift) + lba, 1, m_tmpBuffer.get());
         if (err)
           return err;
         memcpy(ptr, m_tmpBuffer.get(), len);
@@ -250,30 +237,25 @@ public:
     }
 
   public:
-        uint64_t read(void* buf, uint64_t length)
-        {
+    uint64_t read(void* buf, uint64_t length) override {
       uint8_t extra[4];
       uint64_t rem_offset = m_offset % 4;
-            if (rem_offset)
-            {
+      if (rem_offset) {
         uint64_t rem_rem = 4 - rem_offset;
         if (wbfsDiscRead((uint32_t)(m_offset / 4), extra, 4))
           return 0;
         memcpy(buf, extra + rem_offset, rem_rem);
         if (wbfsDiscRead((uint32_t)(m_offset / 4 + 1), (uint8_t*)buf + rem_rem, length - rem_rem))
           return 0;
-            }
-            else
-            {
+      } else {
         if (wbfsDiscRead((uint32_t)(m_offset / 4), (uint8_t*)buf, length))
           return 0;
       }
       m_offset += length;
       return length;
     }
-        uint64_t position() const {return m_offset;}
-        void seek(int64_t offset, int whence)
-        {
+    uint64_t position() const override { return m_offset; }
+    void seek(int64_t offset, int whence) override {
       if (whence == SEEK_SET)
         m_offset = offset;
       else if (whence == SEEK_CUR)
@@ -281,25 +263,20 @@ public:
     }
   };
 
-    std::unique_ptr<IReadStream> beginReadStream(uint64_t offset) const
-    {
-        bool Err = false;
-        auto ret = std::unique_ptr<IReadStream>(new ReadStream(*this, NewFileIO(filepath)->beginReadStream(), offset, Err));
-        if (Err)
-            return {};
+  std::unique_ptr<IReadStream> beginReadStream(uint64_t offset) const override {
+    bool err = false;
+    auto ret = std::unique_ptr<IReadStream>(new ReadStream(*this, NewFileIO(filepath)->beginReadStream(), offset, err));
+
+    if (err) {
+      return nullptr;
+    }
+
     return ret;
   }
 
-    std::unique_ptr<IWriteStream> beginWriteStream(uint64_t offset) const
-    {
-        return std::unique_ptr<IWriteStream>();
-    }
+  std::unique_ptr<IWriteStream> beginWriteStream(uint64_t offset) const override { return nullptr; }
 };
 
-std::unique_ptr<IDiscIO> NewDiscIOWBFS(const SystemChar* path)
-{
-    return std::unique_ptr<IDiscIO>(new DiscIOWBFS(path));
-}
-
-}
+std::unique_ptr<IDiscIO> NewDiscIOWBFS(SystemStringView path) { return std::make_unique<DiscIOWBFS>(path); }
 
+} // namespace nod

lib/FileIOFILE.cpp

@@ -1,34 +1,32 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <inttypes.h>
-#include "nod/Util.hpp"
+#include <cinttypes>
+#include <cstdio>
+#include <cstdint>
+#include <cstdlib>
+
 #include "nod/IFileIO.hpp"
+#include "nod/Util.hpp"
 
-namespace nod
-{
+#include <logvisor/logvisor.hpp>
 
-class FileIOFILE : public IFileIO
-{
+namespace nod {
+
+class FileIOFILE : public IFileIO {
   SystemString m_path;
   int64_t m_maxWriteSize;
-public:
-    FileIOFILE(const SystemString& path, int64_t maxWriteSize)
-    : m_path(path), m_maxWriteSize(maxWriteSize) {}
-    FileIOFILE(const SystemChar* path, int64_t maxWriteSize)
-    : m_path(path), m_maxWriteSize(maxWriteSize) {}
 
-    bool exists()
-    {
-        FILE* fp = fopen(m_path.c_str(), "rb");
+public:
+  FileIOFILE(SystemStringView path, int64_t maxWriteSize) : m_path(path), m_maxWriteSize(maxWriteSize) {}
+
+  bool exists() override {
+    FILE* fp = Fopen(m_path.c_str(), _SYS_STR("rb"));
     if (!fp)
       return false;
     fclose(fp);
     return true;
   }
 
-    uint64_t size()
-    {
-        FILE* fp = fopen(m_path.c_str(), "rb");
+  uint64_t size() override {
+    FILE* fp = Fopen(m_path.c_str(), _SYS_STR("rb"));
     if (!fp)
       return 0;
     FSeek(fp, 0, SEEK_END);
@@ -37,120 +35,95 @@ public:
     return result;
   }
 
-    struct WriteStream : public IFileIO::IWriteStream
-    {
+  struct WriteStream : public IFileIO::IWriteStream {
     FILE* fp;
     int64_t m_maxWriteSize;
-        WriteStream(const SystemString& path, int64_t maxWriteSize, bool& err)
-        : m_maxWriteSize(maxWriteSize)
-        {
-            fp = fopen(path.c_str(), "wb");
-            if (!fp)
-            {
-                LogModule.report(logvisor::Error, _S("unable to open '%s' for writing"), path.c_str());
+    WriteStream(SystemStringView path, int64_t maxWriteSize, bool& err) : m_maxWriteSize(maxWriteSize) {
+      fp = Fopen(path.data(), _SYS_STR("wb"));
+      if (!fp) {
+        LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to open '{}' for writing")), path);
         err = true;
       }
     }
-        WriteStream(const SystemString& path, uint64_t offset, int64_t maxWriteSize, bool& err)
-        : m_maxWriteSize(maxWriteSize)
-        {
-            fp = fopen(path.c_str(), "ab");
+    WriteStream(SystemStringView path, uint64_t offset, int64_t maxWriteSize, bool& err)
+    : m_maxWriteSize(maxWriteSize) {
+      fp = Fopen(path.data(), _SYS_STR("ab"));
       if (!fp)
         goto FailLoc;
       fclose(fp);
-            fp = fopen(path.c_str(), "r+b");
+      fp = Fopen(path.data(), _SYS_STR("r+b"));
       if (!fp)
         goto FailLoc;
       FSeek(fp, offset, SEEK_SET);
       return;
     FailLoc:
-            LogModule.report(logvisor::Error, _S("unable to open '%s' for writing"), path.c_str());
+      LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to open '{}' for writing")), path);
       err = true;
     }
-        ~WriteStream()
-        {
-            fclose(fp);
-        }
-        uint64_t write(const void* buf, uint64_t length)
-        {
-            if (m_maxWriteSize >= 0)
-            {
-                if (FTell(fp) + length > m_maxWriteSize)
-                {
-                    LogModule.report(logvisor::Error, _S("write operation exceeds file's %" PRIi64 "-byte limit"), m_maxWriteSize);
+    ~WriteStream() override { fclose(fp); }
+    uint64_t write(const void* buf, uint64_t length) override {
+      if (m_maxWriteSize >= 0) {
+        if (FTell(fp) + length > m_maxWriteSize) {
+          LogModule.report(logvisor::Error, fmt(_SYS_STR("write operation exceeds file's {}-byte limit")),
+                           m_maxWriteSize);
           return 0;
         }
       }
       return fwrite(buf, 1, length, fp);
     }
   };
-    std::unique_ptr<IWriteStream> beginWriteStream() const
-    {
-        bool Err = false;
-        auto ret = std::unique_ptr<IWriteStream>(new WriteStream(m_path, m_maxWriteSize, Err));
-        if (Err)
-            return {};
-        return ret;
+
+  std::unique_ptr<IWriteStream> beginWriteStream() const override {
+    bool err = false;
+    auto ret = std::unique_ptr<IWriteStream>(new WriteStream(m_path, m_maxWriteSize, err));
+
+    if (err) {
+      return nullptr;
     }
-    std::unique_ptr<IWriteStream> beginWriteStream(uint64_t offset) const
-    {
-        bool Err = false;
-        auto ret = std::unique_ptr<IWriteStream>(new WriteStream(m_path, offset, m_maxWriteSize, Err));
-        if (Err)
-            return {};
+
     return ret;
   }
 
-    struct ReadStream : public IFileIO::IReadStream
-    {
+  std::unique_ptr<IWriteStream> beginWriteStream(uint64_t offset) const override {
+    bool err = false;
+    auto ret = std::unique_ptr<IWriteStream>(new WriteStream(m_path, offset, m_maxWriteSize, err));
+
+    if (err) {
+      return nullptr;
+    }
+
+    return ret;
+  }
+
+  struct ReadStream : public IFileIO::IReadStream {
     FILE* fp;
-        ReadStream(const SystemString& path, bool& err)
-        {
-            fp = fopen(path.c_str(), "rb");
-            if (!fp)
-            {
+    ReadStream(SystemStringView path, bool& err) {
+      fp = Fopen(path.data(), _SYS_STR("rb"));
+      if (!fp) {
         err = true;
-                LogModule.report(logvisor::Error, _S("unable to open '%s' for reading"), path.c_str());
+        LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to open '{}' for reading")), path);
       }
     }
-        ReadStream(const SystemString& path, uint64_t offset, bool& err)
-        : ReadStream(path, err)
-        {
+    ReadStream(SystemStringView path, uint64_t offset, bool& err) : ReadStream(path, err) {
       if (err)
         return;
       FSeek(fp, offset, SEEK_SET);
     }
-        ~ReadStream()
-        {
-            fclose(fp);
-        }
-        void seek(int64_t offset, int whence)
-        {
-            FSeek(fp, offset, whence);
-        }
-        uint64_t position() const
-        {
-            return FTell(fp);
-        }
-        uint64_t read(void* buf, uint64_t length)
-        {
-            return fread(buf, 1, length, fp);
-        }
-        uint64_t copyToDisc(IPartWriteStream& discio, uint64_t length)
-        {
+    ~ReadStream() override { fclose(fp); }
+    void seek(int64_t offset, int whence) override { FSeek(fp, offset, whence); }
+    uint64_t position() const override { return FTell(fp); }
+    uint64_t read(void* buf, uint64_t length) override { return fread(buf, 1, length, fp); }
+    uint64_t copyToDisc(IPartWriteStream& discio, uint64_t length) override {
       uint64_t written = 0;
       uint8_t buf[0x7c00];
-            while (length)
-            {
+      while (length) {
         uint64_t thisSz = nod::min(uint64_t(0x7c00), length);
-                if (read(buf, thisSz) != thisSz)
-                {
-                    LogModule.report(logvisor::Error, "unable to read enough from file");
+        if (read(buf, thisSz) != thisSz) {
+          LogModule.report(logvisor::Error, fmt("unable to read enough from file"));
           return written;
         }
-                if (discio.write(buf, thisSz) != thisSz)
-                {
-                    LogModule.report(logvisor::Error, "unable to write enough to disc");
+        if (discio.write(buf, thisSz) != thisSz) {
+          LogModule.report(logvisor::Error, fmt("unable to write enough to disc"));
           return written;
         }
         length -= thisSz;
@@ -159,32 +132,32 @@ public:
       return written;
     }
   };
-    std::unique_ptr<IReadStream> beginReadStream() const
-    {
-        bool Err = false;
-        auto ret = std::unique_ptr<IReadStream>(new ReadStream(m_path, Err));
-        if (Err)
-            return {};
+
+  std::unique_ptr<IReadStream> beginReadStream() const override {
+    bool err = false;
+    auto ret = std::unique_ptr<IReadStream>(new ReadStream(m_path, err));
+
+    if (err) {
+      return nullptr;
+    }
+
     return ret;
   }
-    std::unique_ptr<IReadStream> beginReadStream(uint64_t offset) const
-    {
-        bool Err = false;
-        auto ret = std::unique_ptr<IReadStream>(new ReadStream(m_path, offset, Err));
-        if (Err)
-            return {};
+
+  std::unique_ptr<IReadStream> beginReadStream(uint64_t offset) const override {
+    bool err = false;
+    auto ret = std::unique_ptr<IReadStream>(new ReadStream(m_path, offset, err));
+
+    if (err) {
+      return nullptr;
+    }
+
     return ret;
   }
 };
 
-std::unique_ptr<IFileIO> NewFileIO(const SystemString& path, int64_t maxWriteSize)
-{
-    return std::unique_ptr<IFileIO>(new FileIOFILE(path, maxWriteSize));
+std::unique_ptr<IFileIO> NewFileIO(SystemStringView path, int64_t maxWriteSize) {
+  return std::make_unique<FileIOFILE>(path, maxWriteSize);
 }
 
-std::unique_ptr<IFileIO> NewFileIO(const SystemChar* path, int64_t maxWriteSize)
-{
-    return std::unique_ptr<IFileIO>(new FileIOFILE(path, maxWriteSize));
-}
-
-}
+} // namespace nod

lib/FileIOWin32.cpp

@@ -1,41 +1,46 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <inttypes.h>
-#include "nod/Util.hpp"
+#include <cinttypes>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+
 #include "nod/IFileIO.hpp"
+#include "nod/Util.hpp"
 
-namespace nod
-{
+#include <logvisor/logvisor.hpp>
 
-class FileIOWin32 : public IFileIO
-{
+namespace nod {
+
+class FileIOWin32 : public IFileIO {
   SystemString m_path;
   int64_t m_maxWriteSize;
-public:
-    FileIOWin32(const SystemString& path, int64_t maxWriteSize)
-    : m_path(path), m_maxWriteSize(maxWriteSize) {}
-    FileIOWin32(const SystemChar* path, int64_t maxWriteSize)
-    : m_path(path), m_maxWriteSize(maxWriteSize) {}
 
-    bool exists()
-    {
-        HANDLE fp = CreateFileW(m_path.c_str(), GENERIC_READ, FILE_SHARE_READ,
-                                nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+public:
+  FileIOWin32(SystemStringView path, int64_t maxWriteSize) : m_path(path), m_maxWriteSize(maxWriteSize) {}
+
+  bool exists() override {
+#if !WINDOWS_STORE
+    HANDLE fp = CreateFileW(m_path.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
+                            FILE_ATTRIBUTE_NORMAL, nullptr);
+#else
+    HANDLE fp = CreateFile2(m_path.c_str(), GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr);
+#endif
     if (fp == INVALID_HANDLE_VALUE)
       return false;
     CloseHandle(fp);
     return true;
   }
 
-    uint64_t size()
-    {
-        HANDLE fp = CreateFileW(m_path.c_str(), GENERIC_READ, FILE_SHARE_READ,
-                                nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+  uint64_t size() override {
+#if !WINDOWS_STORE
+    HANDLE fp = CreateFileW(m_path.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
+                            FILE_ATTRIBUTE_NORMAL, nullptr);
+#else
+    HANDLE fp = CreateFile2(m_path.c_str(), GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr);
+#endif
     if (fp == INVALID_HANDLE_VALUE)
       return 0;
     LARGE_INTEGER sz;
-        if (!GetFileSizeEx(fp, &sz))
-        {
+    if (!GetFileSizeEx(fp, &sz)) {
       CloseHandle(fp);
       return 0;
     }
@@ -43,29 +48,31 @@ public:
     return sz.QuadPart;
   }
 
-    struct WriteStream : public IFileIO::IWriteStream
-    {
+  struct WriteStream : public IFileIO::IWriteStream {
     HANDLE fp;
     int64_t m_maxWriteSize;
-        WriteStream(const SystemString& path, int64_t maxWriteSize, bool& err)
-        : m_maxWriteSize(maxWriteSize)
-        {
-            fp = CreateFileW(path.c_str(), GENERIC_WRITE, FILE_SHARE_WRITE,
-                             nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
-            if (fp == INVALID_HANDLE_VALUE)
-            {
-                LogModule.report(logvisor::Error, _S("unable to open '%s' for writing"), path.c_str());
+    WriteStream(SystemStringView path, int64_t maxWriteSize, bool& err) : m_maxWriteSize(maxWriteSize) {
+#if !WINDOWS_STORE
+      fp = CreateFileW(path.data(), GENERIC_WRITE, FILE_SHARE_WRITE, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,
+                       nullptr);
+#else
+      fp = CreateFile2(path.data(), GENERIC_WRITE, FILE_SHARE_WRITE, CREATE_ALWAYS, nullptr);
+#endif
+      if (fp == INVALID_HANDLE_VALUE) {
+        LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to open '{}' for writing")), path);
         err = true;
       }
     }
-        WriteStream(const SystemString& path, uint64_t offset, int64_t maxWriteSize, bool& err)
-        : m_maxWriteSize(maxWriteSize)
-        {
-            fp = CreateFileW(path.c_str(), GENERIC_WRITE, FILE_SHARE_WRITE,
-                             nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
-            if (fp == INVALID_HANDLE_VALUE)
-            {
-                LogModule.report(logvisor::Error, _S("unable to open '%s' for writing"), path.c_str());
+    WriteStream(SystemStringView path, uint64_t offset, int64_t maxWriteSize, bool& err)
+    : m_maxWriteSize(maxWriteSize) {
+#if !WINDOWS_STORE
+      fp = CreateFileW(path.data(), GENERIC_WRITE, FILE_SHARE_WRITE, nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL,
+                       nullptr);
+#else
+      fp = CreateFile2(path.data(), GENERIC_WRITE, FILE_SHARE_WRITE, OPEN_ALWAYS, nullptr);
+#endif
+      if (fp == INVALID_HANDLE_VALUE) {
+        LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to open '{}' for writing")), path);
         err = true;
         return;
       }
@@ -73,20 +80,15 @@ public:
       lioffset.QuadPart = offset;
       SetFilePointerEx(fp, lioffset, nullptr, FILE_BEGIN);
     }
-        ~WriteStream()
-        {
-            CloseHandle(fp);
-        }
-        uint64_t write(const void* buf, uint64_t length)
-        {
-            if (m_maxWriteSize >= 0)
-            {
+    ~WriteStream() override { CloseHandle(fp); }
+    uint64_t write(const void* buf, uint64_t length) override {
+      if (m_maxWriteSize >= 0) {
         LARGE_INTEGER li = {};
         LARGE_INTEGER res;
         SetFilePointerEx(fp, li, &res, FILE_CURRENT);
-                if (res.QuadPart + int64_t(length) > m_maxWriteSize)
-                {
-                    LogModule.report(logvisor::Error, _S("write operation exceeds file's %" PRIi64 "-byte limit"), m_maxWriteSize);
+        if (res.QuadPart + int64_t(length) > m_maxWriteSize) {
+          LogModule.report(logvisor::Error, fmt(_SYS_STR("write operation exceeds file's {}-byte limit")),
+                           m_maxWriteSize);
           return 0;
         }
       }
@@ -96,83 +98,76 @@ public:
       return ret;
     }
   };
-    std::unique_ptr<IWriteStream> beginWriteStream() const
-    {
-        bool Err = false;
-        auto ret = std::unique_ptr<IWriteStream>(new WriteStream(m_path, m_maxWriteSize, Err));
-        if (Err)
-            return {};
+  std::unique_ptr<IWriteStream> beginWriteStream() const override {
+    bool err = false;
+    auto ret = std::make_unique<WriteStream>(m_path, m_maxWriteSize, err);
+
+    if (err) {
+      return nullptr;
+    }
+
     return ret;
   }
-    std::unique_ptr<IWriteStream> beginWriteStream(uint64_t offset) const
-    {
-        bool Err = false;
-        auto ret = std::unique_ptr<IWriteStream>(new WriteStream(m_path, offset, m_maxWriteSize, Err));
-        if (Err)
-            return {};
+  std::unique_ptr<IWriteStream> beginWriteStream(uint64_t offset) const override {
+    bool err = false;
+    auto ret = std::make_unique<WriteStream>(m_path, offset, m_maxWriteSize, err);
+
+    if (err) {
+      return nullptr;
+    }
+
     return ret;
   }
 
-    struct ReadStream : public IFileIO::IReadStream
-    {
+  struct ReadStream : public IFileIO::IReadStream {
     HANDLE fp;
-        ReadStream(const SystemString& path, bool& err)
-        {
-            fp = CreateFileW(path.c_str(), GENERIC_READ, FILE_SHARE_READ,
-                             nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
-            if (fp == INVALID_HANDLE_VALUE)
-            {
+    ReadStream(SystemStringView path, bool& err) {
+#if !WINDOWS_STORE
+      fp = CreateFileW(path.data(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
+                       nullptr);
+#else
+      fp = CreateFile2(path.data(), GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr);
+#endif
+      if (fp == INVALID_HANDLE_VALUE) {
         err = true;
-                LogModule.report(logvisor::Error, _S("unable to open '%s' for reading"), path.c_str());
+        LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to open '{}' for reading")), path);
       }
     }
-        ReadStream(const SystemString& path, uint64_t offset, bool& err)
-        : ReadStream(path, err)
-        {
+    ReadStream(SystemStringView path, uint64_t offset, bool& err) : ReadStream(path, err) {
       if (err)
         return;
       LARGE_INTEGER lioffset;
       lioffset.QuadPart = offset;
       SetFilePointerEx(fp, lioffset, nullptr, FILE_BEGIN);
     }
-        ~ReadStream()
-        {
-            CloseHandle(fp);
-        }
-        void seek(int64_t offset, int whence)
-        {
+    ~ReadStream() override { CloseHandle(fp); }
+    void seek(int64_t offset, int whence) override {
       LARGE_INTEGER li;
       li.QuadPart = offset;
       SetFilePointerEx(fp, li, nullptr, whence);
     }
-        uint64_t position() const
-        {
+    uint64_t position() const override {
       LARGE_INTEGER li = {};
       LARGE_INTEGER res;
       SetFilePointerEx(fp, li, &res, FILE_CURRENT);
       return res.QuadPart;
     }
-        uint64_t read(void* buf, uint64_t length)
-        {
+    uint64_t read(void* buf, uint64_t length) override {
       DWORD ret = 0;
       ReadFile(fp, buf, length, &ret, nullptr);
       return ret;
     }
-        uint64_t copyToDisc(IPartWriteStream& discio, uint64_t length)
-        {
+    uint64_t copyToDisc(IPartWriteStream& discio, uint64_t length) override {
       uint64_t written = 0;
       uint8_t buf[0x7c00];
-            while (length)
-            {
+      while (length) {
         uint64_t thisSz = nod::min(uint64_t(0x7c00), length);
-                if (read(buf, thisSz) != thisSz)
-                {
-                    LogModule.report(logvisor::Error, "unable to read enough from file");
+        if (read(buf, thisSz) != thisSz) {
+          LogModule.report(logvisor::Error, fmt("unable to read enough from file"));
           return written;
         }
-                if (discio.write(buf, thisSz) != thisSz)
-                {
-                    LogModule.report(logvisor::Error, "unable to write enough to disc");
+        if (discio.write(buf, thisSz) != thisSz) {
+          LogModule.report(logvisor::Error, fmt("unable to write enough to disc"));
           return written;
         }
         length -= thisSz;
@@ -181,32 +176,32 @@ public:
       return written;
     }
   };
-    std::unique_ptr<IReadStream> beginReadStream() const
-    {
-        bool Err = false;
-        auto ret = std::unique_ptr<IReadStream>(new ReadStream(m_path, Err));
-        if (Err)
-            return {};
+
+  std::unique_ptr<IReadStream> beginReadStream() const override {
+    bool err = false;
+    auto ret = std::make_unique<ReadStream>(m_path, err);
+
+    if (err) {
+      return nullptr;
+    }
+
     return ret;
   }
-    std::unique_ptr<IReadStream> beginReadStream(uint64_t offset) const
-    {
-        bool Err = false;
-        auto ret = std::unique_ptr<IReadStream>(new ReadStream(m_path, offset, Err));
-        if (Err)
-            return {};
+
+  std::unique_ptr<IReadStream> beginReadStream(uint64_t offset) const override {
+    bool err = false;
+    auto ret = std::make_unique<ReadStream>(m_path, offset, err);
+
+    if (err) {
+      return nullptr;
+    }
+
     return ret;
   }
 };
 
-std::unique_ptr<IFileIO> NewFileIO(const SystemString& path, int64_t maxWriteSize)
-{
-    return std::unique_ptr<IFileIO>(new FileIOWin32(path, maxWriteSize));
+std::unique_ptr<IFileIO> NewFileIO(SystemStringView path, int64_t maxWriteSize) {
+  return std::make_unique<FileIOWin32>(path, maxWriteSize);
 }
 
-std::unique_ptr<IFileIO> NewFileIO(const SystemChar* path, int64_t maxWriteSize)
-{
-    return std::unique_ptr<IFileIO>(new FileIOWin32(path, maxWriteSize));
-}
-
-}
+} // namespace nod

lib/aes.cpp

@@ -1,6 +1,6 @@
 #include "nod/aes.hpp"
-#include <stdio.h>
-#include <string.h>
+#include <cstdio>
+#include <cstring>
 
 #if _WIN32
 #include <intrin.h>
@@ -8,29 +8,30 @@
 #include <cpuid.h>
 #endif
 
-namespace nod
-{
+#if __AES__ || (!defined(__clang__) && _MSC_VER >= 1800)
+#define _AES_NI 1
+#endif
+
+namespace nod {
 
 /* rotates x one bit to the left */
 
-#define ROTL(x) (((x)>>7)|((x)<<1))
+#define ROTL(x) (((x) >> 7) | ((x) << 1))
 
 /* Rotates 32-bit word left by 1, 2 or 3 byte  */
 
-#define ROTL8(x) (((x)<<8)|((x)>>24))
-#define ROTL16(x) (((x)<<16)|((x)>>16))
-#define ROTL24(x) (((x)<<24)|((x)>>8))
+#define ROTL8(x) (((x) << 8) | ((x) >> 24))
+#define ROTL16(x) (((x) << 16) | ((x) >> 16))
+#define ROTL24(x) (((x) << 24) | ((x) >> 8))
 
 static const uint8_t InCo[4] = {0xB, 0xD, 0x9, 0xE}; /* Inverse Coefficients */
 
-static inline uint32_t pack(const uint8_t* b)
-{
+static uint32_t pack(const uint8_t* b) {
   /* pack bytes into a 32-bit Word */
   return ((uint32_t)b[3] << 24) | ((uint32_t)b[2] << 16) | ((uint32_t)b[1] << 8) | (uint32_t)b[0];
 }
 
-static inline void unpack(uint32_t a, uint8_t* b)
-{
+static void unpack(uint32_t a, uint8_t* b) {
   /* unpack bytes from a word */
   b[0] = (uint8_t)a;
   b[1] = (uint8_t)(a >> 8);
@@ -38,13 +39,9 @@ static inline void unpack(uint32_t a, uint8_t* b)
   b[3] = (uint8_t)(a >> 24);
 }
 
-static inline uint8_t xtime(uint8_t a)
-{
-    return ((a << 1) ^ (((a>>7) & 1) * 0x11B));
-}
+constexpr uint8_t xtime(uint8_t a) { return ((a << 1) ^ (((a >> 7) & 1) * 0x11B)); }
 
-static const struct SoftwareAESTables
-{
+static const struct SoftwareAESTables {
   uint8_t fbsub[256];
   uint8_t rbsub[256];
   uint8_t ptab[256], ltab[256];
@@ -52,15 +49,15 @@ static const struct SoftwareAESTables
   uint32_t rtable[256];
   uint32_t rco[30];
 
-    uint8_t bmul(uint8_t x, uint8_t y) const
-    {
+  uint8_t bmul(uint8_t x, uint8_t y) const {
     /* x.y= AntiLog(Log(x) + Log(y)) */
-        if (x && y) return ptab[(ltab[x] + ltab[y]) % 255];
-        else return 0;
+    if (x && y)
+      return ptab[(ltab[x] + ltab[y]) % 255];
+    else
+      return 0;
   }
 
-    uint32_t SubByte(uint32_t a) const
-    {
+  uint32_t SubByte(uint32_t a) const {
     uint8_t b[4];
     unpack(a, b);
     b[0] = fbsub[b[0]];
@@ -70,17 +67,15 @@ static const struct SoftwareAESTables
     return pack(b);
   }
 
-    uint8_t product(uint32_t x, uint32_t y) const
-    {
+  uint8_t product(uint32_t x, uint32_t y) const {
     /* dot product of two 4-byte arrays */
     uint8_t xb[4], yb[4];
     unpack(x, xb);
     unpack(y, yb);
-        return bmul(xb[0], yb[0])^bmul(xb[1], yb[1])^bmul(xb[2], yb[2])^bmul(xb[3], yb[3]);
+    return bmul(xb[0], yb[0]) ^ bmul(xb[1], yb[1]) ^ bmul(xb[2], yb[2]) ^ bmul(xb[3], yb[3]);
   }
 
-    uint32_t InvMixCol(uint32_t x) const
-    {
+  uint32_t InvMixCol(uint32_t x) const {
     /* matrix Multiplication */
     uint32_t y, m;
     uint8_t b[4];
@@ -97,8 +92,7 @@ static const struct SoftwareAESTables
     return y;
   }
 
-    uint8_t ByteSub(uint8_t x) const
-    {
+  uint8_t ByteSub(uint8_t x) const {
     uint8_t y = ptab[255 - ltab[x]]; /* multiplicative inverse */
     x = y;
     x = ROTL(x);
@@ -113,8 +107,7 @@ static const struct SoftwareAESTables
     return y;
   }
 
-    SoftwareAESTables()
-    {
+  SoftwareAESTables() {
     /* generate tables */
     int i;
     uint8_t y, b[4];
@@ -127,8 +120,7 @@ static const struct SoftwareAESTables
     ptab[1] = 3;
     ltab[3] = 1;
 
-        for (i = 2; i < 256; i++)
-        {
+    for (i = 2; i < 256; i++) {
       ptab[i] = ptab[i - 1] ^ xtime(ptab[i - 1]);
       ltab[ptab[i]] = i;
     }
@@ -138,22 +130,19 @@ static const struct SoftwareAESTables
     fbsub[0] = 0x63;
     rbsub[0x63] = 0;
 
-        for (i = 1; i < 256; i++)
-        {
+    for (i = 1; i < 256; i++) {
       y = ByteSub((uint8_t)i);
       fbsub[i] = y;
       rbsub[y] = i;
     }
 
-        for (i = 0, y = 1; i < 30; i++)
-        {
+    for (i = 0, y = 1; i < 30; i++) {
       rco[i] = y;
       y = xtime(y);
     }
 
     /* calculate forward and reverse tables */
-        for (i = 0; i < 256; i++)
-        {
+    for (i = 0; i < 256; i++) {
       y = fbsub[i];
       b[3] = y ^ xtime(y);
       b[2] = y;
@@ -171,8 +160,7 @@ static const struct SoftwareAESTables
   }
 } AEStb;
 
-class SoftwareAES : public IAES
-{
+class SoftwareAES : public IAES {
 protected:
   /* Parameter-dependent data */
   int Nk, Nb, Nr;
@@ -185,13 +173,12 @@ protected:
   void _decrypt(uint8_t* buff);
 
 public:
-    void encrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outbuf, size_t len);
-    void decrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outbuf, size_t len);
-    void setKey(const uint8_t* key);
+  void encrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outbuf, size_t len) override;
+  void decrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outbuf, size_t len) override;
+  void setKey(const uint8_t* key) override;
 };
 
-void SoftwareAES::gkey(int nb, int nk, const uint8_t* key)
-{
+void SoftwareAES::gkey(int nb, int nk, const uint8_t* key) {
   /* blocksize=32*nb bits. Key=32*nk bits */
   /* currently nb,bk = 4, 6 or 8          */
   /* key comes as 4*Nk bytes              */
@@ -204,17 +191,23 @@ void SoftwareAES::gkey(int nb, int nk, const uint8_t* key)
   Nk = nk;
 
   /* Nr is number of rounds */
-    if (Nb >= Nk) Nr = 6 + Nb;
-    else        Nr = 6 + Nk;
+  if (Nb >= Nk)
+    Nr = 6 + Nb;
+  else
+    Nr = 6 + Nk;
 
   C1 = 1;
 
-    if (Nb < 8) { C2 = 2; C3 = 3; }
-    else      { C2 = 3; C3 = 4; }
+  if (Nb < 8) {
+    C2 = 2;
+    C3 = 3;
+  } else {
+    C2 = 3;
+    C3 = 4;
+  }
 
   /* pre-calculate forward and reverse increments */
-    for (m = j = 0; j < nb; j++, m += 3)
-    {
+  for (m = j = 0; j < nb; j++, m += 3) {
     fi[m] = (j + C1) % nb;
     fi[m + 1] = (j + C2) % nb;
     fi[m + 2] = (j + C3) % nb;
@@ -225,61 +218,56 @@ void SoftwareAES::gkey(int nb, int nk, const uint8_t* key)
 
   N = Nb * (Nr + 1);
 
-    for (i = j = 0; i < Nk; i++, j += 4)
-    {
+  for (i = j = 0; i < Nk; i++, j += 4) {
     CipherKey[i] = pack(key + j);
   }
 
-    for (i = 0; i < Nk; i++) fkey[i] = CipherKey[i];
+  for (i = 0; i < Nk; i++)
+    fkey[i] = CipherKey[i];
 
-    for (j = Nk, k = 0; j < N; j += Nk, k++)
-    {
-        fkey[j] = fkey[j - Nk] ^ AEStb.SubByte(ROTL24(fkey[j - 1]))^AEStb.rco[k];
+  for (j = Nk, k = 0; j < N; j += Nk, k++) {
+    fkey[j] = fkey[j - Nk] ^ AEStb.SubByte(ROTL24(fkey[j - 1])) ^ AEStb.rco[k];
 
-        if (Nk <= 6)
-        {
+    if (Nk <= 6) {
       for (i = 1; i < Nk && (i + j) < N; i++)
         fkey[i + j] = fkey[i + j - Nk] ^ fkey[i + j - 1];
-        }
-        else
-        {
+    } else {
       for (i = 1; i < 4 && (i + j) < N; i++)
         fkey[i + j] = fkey[i + j - Nk] ^ fkey[i + j - 1];
 
-            if ((j + 4) < N) fkey[j + 4] = fkey[j + 4 - Nk] ^ AEStb.SubByte(fkey[j + 3]);
+      if ((j + 4) < N)
+        fkey[j + 4] = fkey[j + 4 - Nk] ^ AEStb.SubByte(fkey[j + 3]);
 
       for (i = 5; i < Nk && (i + j) < N; i++)
         fkey[i + j] = fkey[i + j - Nk] ^ fkey[i + j - 1];
     }
-
   }
 
   /* now for the expanded decrypt key in reverse order */
 
-    for (j = 0; j < Nb; j++) rkey[j + N - Nb] = fkey[j];
+  for (j = 0; j < Nb; j++)
+    rkey[j + N - Nb] = fkey[j];
 
-    for (i = Nb; i < N - Nb; i += Nb)
-    {
+  for (i = Nb; i < N - Nb; i += Nb) {
     k = N - Nb - i;
 
-        for (j = 0; j < Nb; j++) rkey[k + j] = AEStb.InvMixCol(fkey[i + j]);
+    for (j = 0; j < Nb; j++)
+      rkey[k + j] = AEStb.InvMixCol(fkey[i + j]);
   }
 
-    for (j = N - Nb; j < N; j++) rkey[j - N + Nb] = fkey[j];
+  for (j = N - Nb; j < N; j++)
+    rkey[j - N + Nb] = fkey[j];
 }
 
-
 /* There is an obvious time/space trade-off possible here.     *
  * Instead of just one ftable[], I could have 4, the other     *
  * 3 pre-rotated to save the ROTL8, ROTL16 and ROTL24 overhead */
 
-void SoftwareAES::_encrypt(uint8_t* buff)
-{
+void SoftwareAES::_encrypt(uint8_t* buff) {
   int i, j, k, m;
   uint32_t a[8], b[8], *x, *y, *t;
 
-    for (i = j = 0; i < Nb; i++, j += 4)
-    {
+  for (i = j = 0; i < Nb; i++, j += 4) {
     a[i] = pack(buff + j);
     a[i] ^= fkey[i];
   }
@@ -289,21 +277,17 @@ void SoftwareAES::_encrypt(uint8_t* buff)
   y = b;
 
   /* State alternates between a and b */
-    for (i = 1; i < Nr; i++)
-    {
+  for (i = 1; i < Nr; i++) {
     /* Nr is number of rounds. May be odd. */
 
     /* if Nb is fixed - unroll this next
     loop and hard-code in the values of fi[]  */
 
-        for (m = j = 0; j < Nb; j++, m += 3)
-        {
+    for (m = j = 0; j < Nb; j++, m += 3) {
       /* deal with each 32-bit element of the State */
       /* This is the time-critical bit */
-            y[j] = fkey[k++] ^ AEStb.ftable[(uint8_t)x[j]] ^
-                   ROTL8(AEStb.ftable[(uint8_t)(x[fi[m]] >> 8)])^
-                   ROTL16(AEStb.ftable[(uint8_t)(x[fi[m + 1]] >> 16)])^
-                   ROTL24(AEStb.ftable[(uint8_t)(x[fi[m + 2]] >> 24)]);
+      y[j] = fkey[k++] ^ AEStb.ftable[(uint8_t)x[j]] ^ ROTL8(AEStb.ftable[(uint8_t)(x[fi[m]] >> 8)]) ^
+             ROTL16(AEStb.ftable[(uint8_t)(x[fi[m + 1]] >> 16)]) ^ ROTL24(AEStb.ftable[(uint8_t)(x[fi[m + 2]] >> 24)]);
     }
 
     t = x;
@@ -312,16 +296,13 @@ void SoftwareAES::_encrypt(uint8_t* buff)
   }
 
   /* Last Round - unroll if possible */
-    for (m = j = 0; j < Nb; j++, m += 3)
-    {
-        y[j] = fkey[k++] ^ (uint32_t)AEStb.fbsub[(uint8_t)x[j]] ^
-               ROTL8((uint32_t)AEStb.fbsub[(uint8_t)(x[fi[m]] >> 8)])^
-               ROTL16((uint32_t)AEStb.fbsub[(uint8_t)(x[fi[m + 1]] >> 16)])^
+  for (m = j = 0; j < Nb; j++, m += 3) {
+    y[j] = fkey[k++] ^ (uint32_t)AEStb.fbsub[(uint8_t)x[j]] ^ ROTL8((uint32_t)AEStb.fbsub[(uint8_t)(x[fi[m]] >> 8)]) ^
+           ROTL16((uint32_t)AEStb.fbsub[(uint8_t)(x[fi[m + 1]] >> 16)]) ^
            ROTL24((uint32_t)AEStb.fbsub[(uint8_t)(x[fi[m + 2]] >> 24)]);
   }
 
-    for (i = j = 0; i < Nb; i++, j += 4)
-    {
+  for (i = j = 0; i < Nb; i++, j += 4) {
     unpack(y[i], (uint8_t*)&buff[j]);
     x[i] = y[i] = 0; /* clean up stack */
   }
@@ -329,13 +310,11 @@ void SoftwareAES::_encrypt(uint8_t* buff)
   return;
 }
 
-void SoftwareAES::_decrypt(uint8_t* buff)
-{
+void SoftwareAES::_decrypt(uint8_t* buff) {
   int i, j, k, m;
   uint32_t a[8], b[8], *x, *y, *t;
 
-    for (i = j = 0; i < Nb; i++, j += 4)
-    {
+  for (i = j = 0; i < Nb; i++, j += 4) {
     a[i] = pack(buff + j);
     a[i] ^= rkey[i];
   }
@@ -345,20 +324,16 @@ void SoftwareAES::_decrypt(uint8_t* buff)
   y = b;
 
   /* State alternates between a and b */
-    for (i = 1; i < Nr; i++)
-    {
+  for (i = 1; i < Nr; i++) {
     /* Nr is number of rounds. May be odd. */
 
     /* if Nb is fixed - unroll this next
     loop and hard-code in the values of ri[]  */
 
-        for (m = j = 0; j < Nb; j++, m += 3)
-        {
+    for (m = j = 0; j < Nb; j++, m += 3) {
       /* This is the time-critical bit */
-            y[j] = rkey[k++] ^ AEStb.rtable[(uint8_t)x[j]] ^
-                   ROTL8(AEStb.rtable[(uint8_t)(x[ri[m]] >> 8)])^
-                   ROTL16(AEStb.rtable[(uint8_t)(x[ri[m + 1]] >> 16)])^
-                   ROTL24(AEStb.rtable[(uint8_t)(x[ri[m + 2]] >> 24)]);
+      y[j] = rkey[k++] ^ AEStb.rtable[(uint8_t)x[j]] ^ ROTL8(AEStb.rtable[(uint8_t)(x[ri[m]] >> 8)]) ^
+             ROTL16(AEStb.rtable[(uint8_t)(x[ri[m + 1]] >> 16)]) ^ ROTL24(AEStb.rtable[(uint8_t)(x[ri[m + 2]] >> 24)]);
     }
 
     t = x;
@@ -367,16 +342,13 @@ void SoftwareAES::_decrypt(uint8_t* buff)
   }
 
   /* Last Round - unroll if possible */
-    for (m = j = 0; j < Nb; j++, m += 3)
-    {
-        y[j] = rkey[k++] ^ (uint32_t)AEStb.rbsub[(uint8_t)x[j]] ^
-               ROTL8((uint32_t)AEStb.rbsub[(uint8_t)(x[ri[m]] >> 8)])^
-               ROTL16((uint32_t)AEStb.rbsub[(uint8_t)(x[ri[m + 1]] >> 16)])^
+  for (m = j = 0; j < Nb; j++, m += 3) {
+    y[j] = rkey[k++] ^ (uint32_t)AEStb.rbsub[(uint8_t)x[j]] ^ ROTL8((uint32_t)AEStb.rbsub[(uint8_t)(x[ri[m]] >> 8)]) ^
+           ROTL16((uint32_t)AEStb.rbsub[(uint8_t)(x[ri[m + 1]] >> 16)]) ^
            ROTL24((uint32_t)AEStb.rbsub[(uint8_t)(x[ri[m + 2]] >> 24)]);
   }
 
-    for (i = j = 0; i < Nb; i++, j += 4)
-    {
+  for (i = j = 0; i < Nb; i++, j += 4) {
     unpack(y[i], (uint8_t*)&buff[j]);
     x[i] = y[i] = 0; /* clean up stack */
   }
@@ -384,45 +356,42 @@ void SoftwareAES::_decrypt(uint8_t* buff)
   return;
 }
 
-void SoftwareAES::setKey(const uint8_t* key)
-{
-    gkey(4, 4, key);
-}
+void SoftwareAES::setKey(const uint8_t* key) { gkey(4, 4, key); }
 
 // CBC mode decryption
-void SoftwareAES::decrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outbuf, size_t len)
-{
+void SoftwareAES::decrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outbuf, size_t len) {
   uint8_t block[16];
   const uint8_t* ctext_ptr;
   unsigned int blockno = 0, i;
 
-    //fprintf( stderr,"aes_decrypt(%p, %p, %p, %lld)\n", iv, inbuf, outbuf, len  );
-    //printf("aes_decrypt(%p, %p, %p, %lld)\n", iv, inbuf, outbuf, len);
+  // fprintf( stderr,"aes_decrypt(%p, %p, %p, %lld)\n", iv, inbuf, outbuf, len  );
+  // printf("aes_decrypt(%p, %p, %p, %lld)\n", iv, inbuf, outbuf, len);
 
-    for (blockno = 0; blockno <= (len / sizeof(block)); blockno++)
-    {
+  for (blockno = 0; blockno <= (len / sizeof(block)); blockno++) {
     unsigned int fraction;
 
     if (blockno == (len / sizeof(block))) // last block
     {
       fraction = len % sizeof(block);
 
-            if (fraction == 0) break;
+      if (fraction == 0)
+        break;
 
       memset(block, 0, sizeof(block));
-        }
-        else fraction = 16;
+    } else
+      fraction = 16;
 
     //    debug_printf("block %d: fraction = %d\n", blockno, fraction);
     memcpy(block, inbuf + blockno * sizeof(block), fraction);
     _decrypt(block);
 
-        if (blockno == 0) ctext_ptr = iv;
-        else ctext_ptr = (uint8_t*)(inbuf + (blockno - 1) * sizeof(block));
+    if (blockno == 0)
+      ctext_ptr = iv;
+    else
+      ctext_ptr = (uint8_t*)(inbuf + (blockno - 1) * sizeof(block));
 
     for (i = 0; i < fraction; i++)
-            outbuf[blockno * sizeof(block) + i] =
-                ctext_ptr[i] ^ block[i];
+      outbuf[blockno * sizeof(block) + i] = ctext_ptr[i] ^ block[i];
 
     //    debug_printf("Block %d output: ", blockno);
     //    hexdump(outbuf + blockno*sizeof(block), 16);
@@ -430,29 +399,28 @@ void SoftwareAES::decrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outb
 }
 
 // CBC mode encryption
-void SoftwareAES::encrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outbuf, size_t len)
-{
+void SoftwareAES::encrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outbuf, size_t len) {
   uint8_t block[16];
   uint8_t feedback[16];
   memcpy(feedback, iv, 16);
   unsigned int blockno = 0, i;
 
-    //printf("aes_decrypt(%p, %p, %p, %lld)\n", iv, inbuf, outbuf, len);
-    //fprintf( stderr,"aes_encrypt(%p, %p, %p, %lld)\n", iv, inbuf, outbuf, len);
+  // printf("aes_decrypt(%p, %p, %p, %lld)\n", iv, inbuf, outbuf, len);
+  // fprintf( stderr,"aes_encrypt(%p, %p, %p, %lld)\n", iv, inbuf, outbuf, len);
 
-    for (blockno = 0; blockno <= (len / sizeof(block)); blockno++)
-    {
+  for (blockno = 0; blockno <= (len / sizeof(block)); blockno++) {
     unsigned int fraction;
 
     if (blockno == (len / sizeof(block))) // last block
     {
       fraction = len % sizeof(block);
 
-            if (fraction == 0) break;
+      if (fraction == 0)
+        break;
 
       memset(block, 0, sizeof(block));
-        }
-        else fraction = 16;
+    } else
+      fraction = 16;
 
     //    debug_printf("block %d: fraction = %d\n", blockno, fraction);
     memcpy(block, inbuf + blockno * sizeof(block), fraction);
@@ -468,49 +436,45 @@ void SoftwareAES::encrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outb
   }
 }
 
-#if __AES__ || _MSC_VER >= 1800
+#if _AES_NI
 
 #include <wmmintrin.h>
 
-class NiAES : public IAES
-{
+class NiAES : public IAES {
   __m128i m_ekey[11];
   __m128i m_dkey[11];
+
 public:
-    void encrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outbuf, size_t len)
-    {
-        __m128i feedback,data;
-        uint64_t i,j;
-        if (len%16)
-            len = len/16+1;
+  void encrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outbuf, size_t len) {
+    __m128i feedback, data;
+    uint64_t i, j;
+    if (len % 16)
+      len = len / 16 + 1;
     else
       len /= 16;
     feedback = _mm_loadu_si128((__m128i*)iv);
-        for (i=0 ; i<len ; i++)
-        {
+    for (i = 0; i < len; i++) {
       data = _mm_loadu_si128(&((__m128i*)inbuf)[i]);
       feedback = _mm_xor_si128(data, feedback);
       feedback = _mm_xor_si128(feedback, m_ekey[0]);
-            for (j=1 ; j<10 ; j++)
+      for (j = 1; j < 10; j++)
         feedback = _mm_aesenc_si128(feedback, m_ekey[j]);
       feedback = _mm_aesenclast_si128(feedback, m_ekey[j]);
       _mm_storeu_si128(&((__m128i*)outbuf)[i], feedback);
     }
   }
-    void decrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outbuf, size_t len)
-    {
-        __m128i data,feedback,last_in;
-        uint64_t i,j;
-        if (len%16)
-            len = len/16+1;
+  void decrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outbuf, size_t len) {
+    __m128i data, feedback, last_in;
+    uint64_t i, j;
+    if (len % 16)
+      len = len / 16 + 1;
     else
       len /= 16;
     feedback = _mm_loadu_si128((__m128i*)iv);
-        for (i=0 ; i<len ; i++)
-        {
-            last_in=_mm_loadu_si128(&((__m128i*)inbuf)[i]);
+    for (i = 0; i < len; i++) {
+      last_in = _mm_loadu_si128(&((__m128i*)inbuf)[i]);
       data = _mm_xor_si128(last_in, m_dkey[0]);
-            for (j=1 ; j<10 ; j++)
+      for (j = 1; j < 10; j++)
         data = _mm_aesdec_si128(data, m_dkey[j]);
       data = _mm_aesdeclast_si128(data, m_dkey[j]);
       data = _mm_xor_si128(data, feedback);
@@ -519,22 +483,20 @@ public:
     }
   }
 
-    static inline __m128i AES_128_ASSIST (__m128i temp1, __m128i temp2)
-    {
+  static inline __m128i AES_128_ASSIST(__m128i temp1, __m128i temp2) {
     __m128i temp3;
-        temp2 = _mm_shuffle_epi32 (temp2 ,0xff);
-        temp3 = _mm_slli_si128 (temp1, 0x4);
-        temp1 = _mm_xor_si128 (temp1, temp3);
-        temp3 = _mm_slli_si128 (temp3, 0x4);
-        temp1 = _mm_xor_si128 (temp1, temp3);
-        temp3 = _mm_slli_si128 (temp3, 0x4);
-        temp1 = _mm_xor_si128 (temp1, temp3);
-        temp1 = _mm_xor_si128 (temp1, temp2);
+    temp2 = _mm_shuffle_epi32(temp2, 0xff);
+    temp3 = _mm_slli_si128(temp1, 0x4);
+    temp1 = _mm_xor_si128(temp1, temp3);
+    temp3 = _mm_slli_si128(temp3, 0x4);
+    temp1 = _mm_xor_si128(temp1, temp3);
+    temp3 = _mm_slli_si128(temp3, 0x4);
+    temp1 = _mm_xor_si128(temp1, temp3);
+    temp1 = _mm_xor_si128(temp1, temp2);
     return temp1;
   }
 
-    void setKey(const uint8_t* key)
-    {
+  void setKey(const uint8_t* key) {
     __m128i temp1, temp2;
 
     temp1 = _mm_loadu_si128((__m128i*)key);
@@ -583,32 +545,30 @@ public:
   }
 };
 
+static int HAS_AES_NI = -1;
+
 #endif
 
-static int HAS_AES_NI = -1;
-std::unique_ptr<IAES> NewAES()
-{
-#if __AES__ || _MSC_VER >= 1800
-    if (HAS_AES_NI == -1)
-    {
+std::unique_ptr<IAES> NewAES() {
+#if _AES_NI
+  if (HAS_AES_NI == -1) {
 #if _MSC_VER
     int info[4];
     __cpuid(info, 1);
     HAS_AES_NI = ((info[2] & 0x2000000) != 0);
 #else
-        unsigned int a,b,c,d;
-        __cpuid(1, a,b,c,d);
+    unsigned int a, b, c, d;
+    __cpuid(1, a, b, c, d);
     HAS_AES_NI = ((c & 0x2000000) != 0);
 #endif
   }
   if (HAS_AES_NI)
-        return std::unique_ptr<IAES>(new NiAES);
+    return std::make_unique<NiAES>();
   else
-        return std::unique_ptr<IAES>(new SoftwareAES);
+    return std::make_unique<SoftwareAES>();
 #else
-    return std::unique_ptr<IAES>(new SoftwareAES);
+  return std::make_unique<SoftwareAES>();
 #endif
 }
 
-}
-
+} // namespace nod

lib/nod.cpp

@@ -1,22 +1,23 @@
-#include <stdio.h>
 #include "nod/nod.hpp"
-#include "nod/DiscBase.hpp"
 
-namespace nod
-{
+#include <cstdio>
+
+#include "nod/DiscBase.hpp"
+#include "nod/DiscGCN.hpp"
+#include "nod/DiscWii.hpp"
+
+namespace nod {
 
 logvisor::Module LogModule("nod");
 
-std::unique_ptr<IDiscIO> NewDiscIOISO(const SystemChar* path);
-std::unique_ptr<IDiscIO> NewDiscIOWBFS(const SystemChar* path);
+std::unique_ptr<IDiscIO> NewDiscIOISO(SystemStringView path);
+std::unique_ptr<IDiscIO> NewDiscIOWBFS(SystemStringView path);
 
-std::unique_ptr<DiscBase> OpenDiscFromImage(const SystemChar* path, bool& isWii)
-{
+std::unique_ptr<DiscBase> OpenDiscFromImage(SystemStringView path, bool& isWii) {
   /* Temporary file handle to determine image type */
   std::unique_ptr<IFileIO> fio = NewFileIO(path);
-    if (!fio->exists())
-    {
-        LogModule.report(logvisor::Error, _S("Unable to open '%s'"), path);
+  if (!fio->exists()) {
+    LogModule.report(logvisor::Error, fmt(_SYS_STR("Unable to open '{}'")), path);
     return {};
   }
   std::unique_ptr<IFileIO::IReadStream> rs = fio->beginReadStream();
@@ -26,29 +27,22 @@ std::unique_ptr<DiscBase> OpenDiscFromImage(const SystemChar* path, bool& isWii)
   isWii = false;
   std::unique_ptr<IDiscIO> discIO;
   uint32_t magic = 0;
-    if (rs->read(&magic, 4) != 4)
-    {
-        LogModule.report(logvisor::Error, _S("Unable to read magic from '%s'"), path);
+  if (rs->read(&magic, 4) != 4) {
+    LogModule.report(logvisor::Error, fmt(_SYS_STR("Unable to read magic from '{}'")), path);
     return {};
   }
 
-    if (magic == nod::SBig((uint32_t)'WBFS'))
-    {
+  if (magic == nod::SBig((uint32_t)'WBFS')) {
     discIO = NewDiscIOWBFS(path);
     isWii = true;
-    }
-    else
-    {
+  } else {
     rs->seek(0x18, SEEK_SET);
     rs->read(&magic, 4);
     magic = nod::SBig(magic);
-        if (magic == 0x5D1C9EA3)
-        {
+    if (magic == 0x5D1C9EA3) {
       discIO = NewDiscIOISO(path);
       isWii = true;
-        }
-        else
-        {
+    } else {
       rs->read(&magic, 4);
       magic = nod::SBig(magic);
       if (magic == 0xC2339F3D)
@@ -56,33 +50,31 @@ std::unique_ptr<DiscBase> OpenDiscFromImage(const SystemChar* path, bool& isWii)
     }
   }
 
-    if (!discIO)
-    {
-        LogModule.report(logvisor::Error, _S("'%s' is not a valid image"), path);
+  if (!discIO) {
+    LogModule.report(logvisor::Error, fmt(_SYS_STR("'{}' is not a valid image")), path);
     return {};
   }
 
-    bool Err = false;
+  bool err = false;
   std::unique_ptr<DiscBase> ret;
-    if (isWii)
-    {
-        ret = std::unique_ptr<DiscBase>(new DiscWii(std::move(discIO), Err));
-        if (Err)
-            return {};
+  if (isWii) {
+    ret = std::make_unique<DiscWii>(std::move(discIO), err);
+    if (err) {
+      return nullptr;
+    }
     return ret;
   }
 
-    ret = std::unique_ptr<DiscBase>(new DiscGCN(std::move(discIO), Err));
-    if (Err)
-        return {};
+  ret = std::make_unique<DiscGCN>(std::move(discIO), err);
+  if (err) {
+    return nullptr;
+  }
   return ret;
 }
 
-std::unique_ptr<DiscBase> OpenDiscFromImage(const SystemChar* path)
-{
+std::unique_ptr<DiscBase> OpenDiscFromImage(SystemStringView path) {
   bool isWii;
   return OpenDiscFromImage(path, isWii);
 }
 
-}
-
+} // namespace nod