AxioDL
/
nod
mirror of https://github.com/AxioDL/nod.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update fmtlib

This commit is contained in:
Jack Andersen 2020-04-11 12:45:06 -10:00
parent dffcac50c5
commit 2783337c36
12 changed files with 105 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
driver/main.cpp
View File

@ -11,7 +11,7 @@
#include <nod/nod.hpp>
static void printHelp() {
fmt::print(stderr, fmt(
fmt::print(stderr, FMT_STRING(
"Usage:\n"
" nodtool extract [-f] <image-in> [<dir-out>]\n"
" nodtool makegcn <fsroot-in> [<image-out>]\n"
@ -47,7 +47,7 @@ int main(int argc, char* argv[])
bool verbose = false;
nod::ExtractionContext ctx = {true, [&](std::string_view str, float c) {
if (verbose)
fmt::print(stderr, fmt("Current node: {}, Extraction {:g}% Complete\n"), str,
fmt::print(stderr, FMT_STRING("Current node: {}, Extraction {:g}% Complete\n"), str,
c * 100.f);
}};
const nod::SystemChar* inDir = nullptr;
@ -66,11 +66,11 @@ int main(int argc, char* argv[])
}
auto progFunc = [&](float prog, nod::SystemStringView name, size_t bytes) {
fmt::print(fmt(_SYS_STR("\r ")));
fmt::print(FMT_STRING(_SYS_STR("\r ")));
if (bytes != SIZE_MAX)
fmt::print(fmt(_SYS_STR("\r{:g}% {} {} B")), prog * 100.f, name, bytes);
fmt::print(FMT_STRING(_SYS_STR("\r{:g}% {} {} B")), prog * 100.f, name, bytes);
else
fmt::print(fmt(_SYS_STR("\r{:g}% {}")), prog * 100.f, name);
fmt::print(FMT_STRING(_SYS_STR("\r{:g}% {}")), prog * 100.f, name);
fflush(stdout);
};
@ -92,7 +92,7 @@ int main(int argc, char* argv[])
/* Pre-validate path */
nod::Sstat theStat;
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]);
nod::LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {} as directory")), argv[2]);
return 1;
}
@ -111,14 +111,14 @@ int main(int argc, char* argv[])
ret = b.buildFromDirectory(argv[2]);
}
fmt::print(fmt("\n"));
fmt::print(FMT_STRING("\n"));
if (ret != nod::EBuildResult::Success)
return 1;
} 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, fmt(_SYS_STR("unable to stat {} as directory")), argv[4]);
nod::LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {} as directory")), argv[4]);
return 1;
}
@ -138,29 +138,29 @@ int main(int argc, char* argv[])
ret = b.buildFromDirectory(argv[2]);
}
fmt::print(fmt("\n"));
fmt::print(FMT_STRING("\n"));
if (ret != nod::EBuildResult::Success)
return 1;
} 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, fmt(_SYS_STR("unable to stat {} as directory")), argv[2]);
nod::LogModule.report(logvisor::Error, FMT_STRING(_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, fmt(_SYS_STR("unable to stat {} as file")), argv[3]);
nod::LogModule.report(logvisor::Error, FMT_STRING(_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, fmt(_SYS_STR("unable to open image {}")), argv[3]);
nod::LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to open image {}")), argv[3]);
return 1;
}
if (isWii) {
nod::LogModule.report(logvisor::Error, fmt(_SYS_STR("Wii images should be merged with 'mergewii'")));
nod::LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("Wii images should be merged with 'mergewii'")));
return 1;
}
@ -179,29 +179,29 @@ int main(int argc, char* argv[])
ret = b.mergeFromDirectory(argv[2]);
}
fmt::print(fmt("\n"));
fmt::print(FMT_STRING("\n"));
if (ret != nod::EBuildResult::Success)
return 1;
} 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, fmt(_SYS_STR("unable to stat {} as directory")), argv[2]);
nod::LogModule.report(logvisor::Error, FMT_STRING(_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, fmt(_SYS_STR("unable to stat {} as file")), argv[3]);
nod::LogModule.report(logvisor::Error, FMT_STRING(_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, fmt(_SYS_STR("unable to open image {}")), argv[3]);
nod::LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to open image {}")), argv[3]);
return 1;
}
if (!isWii) {
nod::LogModule.report(logvisor::Error, fmt(_SYS_STR("GameCube images should be merged with 'mergegcn'")));
nod::LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("GameCube images should be merged with 'mergegcn'")));
return 1;
}
@ -221,7 +221,7 @@ int main(int argc, char* argv[])
ret = b.mergeFromDirectory(argv[2]);
}
fmt::print(fmt("\n"));
fmt::print(FMT_STRING("\n"));
if (ret != nod::EBuildResult::Success)
return 1;
} else {
@ -229,6 +229,6 @@ int main(int argc, char* argv[])
return 1;
}
nod::LogModule.report(logvisor::Info, fmt(_SYS_STR("Success!")));
nod::LogModule.report(logvisor::Info, FMT_STRING(_SYS_STR("Success!")));
return 0;
}

8
include/nod/IFileIO.hpp
View File

@ -25,11 +25,11 @@ public:
uint64_t thisSz = nod::min(uint64_t(0x7c00), length);
uint64_t readSz = discio.read(buf, thisSz);
if (thisSz != readSz) {
LogModule.report(logvisor::Error, fmt("unable to read enough from disc"));
LogModule.report(logvisor::Error, FMT_STRING("unable to read enough from disc"));
return read;
}
if (write(buf, readSz) != readSz) {
LogModule.report(logvisor::Error, fmt("unable to write in file"));
LogModule.report(logvisor::Error, FMT_STRING("unable to write in file"));
return read;
}
length -= thisSz;
@ -45,11 +45,11 @@ public:
uint64_t thisSz = nod::min(uint64_t(0x7c00), length);
uint64_t readSz = discio.read(buf, thisSz);
if (thisSz != readSz) {
LogModule.report(logvisor::Error, fmt("unable to read enough from disc"));
LogModule.report(logvisor::Error, FMT_STRING("unable to read enough from disc"));
return read;
}
if (write(buf, readSz) != readSz) {
LogModule.report(logvisor::Error, fmt("unable to write in file"));
LogModule.report(logvisor::Error, FMT_STRING("unable to write in file"));
return read;
}
length -= thisSz;

8
include/nod/Util.hpp
View File

@ -267,7 +267,7 @@ static inline FILE* Fopen(const SystemChar* path, const SystemChar* mode, FileLo
&ov);
#else
if (flock(fileno(fp), ((lock == FileLockType::Write) ? LOCK_EX : LOCK_SH) | LOCK_NB))
LogModule.report(logvisor::Error, fmt("flock {}: {}"), path, strerror(errno));
LogModule.report(logvisor::Error, FMT_STRING("flock {}: {}"), path, strerror(errno));
#endif
}
@ -301,20 +301,20 @@ static inline bool CheckFreeSpace(const SystemChar* path, size_t reqSz) {
wchar_t* end;
DWORD ret = GetFullPathNameW(path, 1024, buf, &end);
if (!ret || ret > 1024) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("GetFullPathNameW {}")), path);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("GetFullPathNameW {}")), path);
return false;
}
if (end)
end[0] = L'\0';
if (!GetDiskFreeSpaceExW(buf, &freeBytes, nullptr, nullptr)) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("GetDiskFreeSpaceExW {}: {}")), path, GetLastError());
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("GetDiskFreeSpaceExW {}: {}")), path, GetLastError());
return false;
}
return reqSz < freeBytes.QuadPart;
#else
struct statvfs svfs;
if (statvfs(path, &svfs)) {
LogModule.report(logvisor::Error, fmt("statvfs {}: {}"), path, strerror(errno));
LogModule.report(logvisor::Error, FMT_STRING("statvfs {}: {}"), path, strerror(errno));
return false;
}
return reqSz < svfs.f_frsize * svfs.f_bavail;

22
lib/DiscBase.cpp
View File

@ -109,7 +109,7 @@ Node::Node(const IPartition& parent, const FSTNode& node, std::string_view name)
std::unique_ptr<IPartReadStream> Node::beginReadStream(uint64_t offset) const {
if (m_kind != Kind::File) {
LogModule.report(logvisor::Error, fmt("unable to stream a non-file {}"), m_name);
LogModule.report(logvisor::Error, FMT_STRING("unable to stream a non-file {}"), m_name);
return std::unique_ptr<IPartReadStream>();
}
return m_parent.beginReadStream(m_discOffset + offset);
@ -117,7 +117,7 @@ std::unique_ptr<IPartReadStream> Node::beginReadStream(uint64_t offset) const {
std::unique_ptr<uint8_t[]> Node::getBuf() const {
if (m_kind != Kind::File) {
LogModule.report(logvisor::Error, fmt("unable to buffer a non-file {}"), m_name);
LogModule.report(logvisor::Error, FMT_STRING("unable to buffer a non-file {}"), m_name);
return nullptr;
}
@ -135,7 +135,7 @@ bool Node::extractToDirectory(SystemStringView basePath, const ExtractionContext
if (ctx.progressCB && !getName().empty())
ctx.progressCB(getName(), m_parent.m_curNodeIdx / float(m_parent.getNodeCount()));
if (Mkdir(path.c_str(), 0755) && errno != EEXIST) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to mkdir '{}'")), path);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to mkdir '{}'")), path);
return false;
}
for (Node& subnode : *this)
@ -164,14 +164,14 @@ bool Node::extractToDirectory(SystemStringView basePath, const ExtractionContext
bool IPartition::extractToDirectory(SystemStringView path, const ExtractionContext& ctx) {
m_curNodeIdx = 0;
if (Mkdir(path.data(), 0755) && errno != EEXIST) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to mkdir '{}'")), path);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to mkdir '{}'")), path);
return false;
}
SystemString basePath = m_isWii ? SystemString(path) + _SYS_STR("/") + getKindString(m_kind) : SystemString(path);
if (m_isWii) {
if (Mkdir(basePath.c_str(), 0755) && errno != EEXIST) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to mkdir '{}'")), basePath);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to mkdir '{}'")), basePath);
return false;
}
}
@ -190,7 +190,7 @@ bool IPartition::extractToDirectory(SystemStringView path, const ExtractionConte
/* Extract Filesystem */
SystemString fsPath = basePath + _SYS_STR("/files");
if (Mkdir(fsPath.c_str(), 0755) && errno != EEXIST) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to mkdir '{}'")), fsPath);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to mkdir '{}'")), fsPath);
return false;
}
@ -200,7 +200,7 @@ bool IPartition::extractToDirectory(SystemStringView path, const ExtractionConte
bool IPartition::extractSysFiles(SystemStringView basePath, const ExtractionContext& ctx) const {
SystemString basePathStr(basePath);
if (Mkdir((basePathStr + _SYS_STR("/sys")).c_str(), 0755) && errno != EEXIST) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to mkdir '{}/sys'")), basePath);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to mkdir '{}/sys'")), basePath);
return false;
}
@ -712,7 +712,7 @@ bool DiscBuilderBase::PartitionBuilderBase::RecursiveCalculateTotalSize(uint64_t
bool DiscBuilderBase::PartitionBuilderBase::buildFromDirectory(IPartWriteStream& ws, SystemStringView dirIn) {
if (dirIn.empty()) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("all arguments must be supplied to buildFromDirectory()")));
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("all arguments must be supplied to buildFromDirectory()")));
return false;
}
@ -737,7 +737,7 @@ bool DiscBuilderBase::PartitionBuilderBase::buildFromDirectory(IPartWriteStream&
{
Sstat dolStat;
if (Stat(dolIn.c_str(), &dolStat)) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {}")), dolIn);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), dolIn);
return false;
}
size_t fileSz = ROUND_UP_32(dolStat.st_size);
@ -778,7 +778,7 @@ std::optional<uint64_t> DiscBuilderBase::PartitionBuilderBase::CalculateTotalSiz
Sstat dolStat;
if (Stat(dolIn.c_str(), &dolStat)) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {}")), dolIn);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), dolIn);
return std::nullopt;
}
uint64_t totalSz = ROUND_UP_32(dolStat.st_size);
@ -790,7 +790,7 @@ std::optional<uint64_t> DiscBuilderBase::PartitionBuilderBase::CalculateTotalSiz
bool DiscBuilderBase::PartitionBuilderBase::mergeFromDirectory(IPartWriteStream& ws, const IPartition* partIn,
SystemStringView dirIn) {
if (dirIn.empty()) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("all arguments must be supplied to mergeFromDirectory()")));
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("all arguments must be supplied to mergeFromDirectory()")));
return false;
}

22
lib/DiscGCN.cpp
View File

@ -168,7 +168,7 @@ public:
m_curUser -= reqSz;
m_curUser &= 0xfffffffffffffff0;
if (m_curUser < 0x30000) {
LogModule.report(logvisor::Error, fmt("user area low mark reached"));
LogModule.report(logvisor::Error, FMT_STRING("user area low mark reached"));
return -1;
}
static_cast<PartWriteStream&>(ws).seek(m_curUser);
@ -211,7 +211,7 @@ public:
fstSz = ROUND_UP_32(fstSz);
if (fstOff + fstSz >= m_curUser) {
LogModule.report(logvisor::Error, fmt("FST flows into user area (one or the other is too big)"));
LogModule.report(logvisor::Error, FMT_STRING("FST flows into user area (one or the other is too big)"));
return false;
}
@ -240,7 +240,7 @@ public:
SystemString apploaderIn = dirStr + _SYS_STR("/sys/apploader.img");
Sstat apploaderStat;
if (Stat(apploaderIn.c_str(), &apploaderStat)) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {}")), apploaderIn);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), apploaderIn);
return false;
}
@ -248,7 +248,7 @@ public:
SystemString bootIn = dirStr + _SYS_STR("/sys/boot.bin");
Sstat bootStat;
if (Stat(bootIn.c_str(), &bootStat)) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {}")), bootIn);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), bootIn);
return false;
}
@ -256,7 +256,7 @@ public:
SystemString bi2In = dirStr + _SYS_STR("/sys/bi2.bin");
Sstat bi2Stat;
if (Stat(bi2In.c_str(), &bi2Stat)) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {}")), bi2In);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), bi2In);
return false;
}
@ -298,7 +298,7 @@ public:
ws.write(buf, rdSz);
xferSz += rdSz;
if (0x2440 + xferSz >= m_curUser) {
LogModule.report(logvisor::Error, fmt("apploader flows into user area (one or the other is too big)"));
LogModule.report(logvisor::Error, FMT_STRING("apploader flows into user area (one or the other is too big)"));
return false;
}
m_parent.m_progressCB(m_parent.getProgressFactor(), apploaderIn, xferSz);
@ -340,7 +340,7 @@ public:
ws.write(apploaderBuf.get(), apploaderSz);
xferSz += apploaderSz;
if (0x2440 + xferSz >= m_curUser) {
LogModule.report(logvisor::Error, fmt("apploader flows into user area (one or the other is too big)"));
LogModule.report(logvisor::Error, FMT_STRING("apploader flows into user area (one or the other is too big)"));
return false;
}
m_parent.m_progressCB(m_parent.getProgressFactor(), apploaderName, xferSz);
@ -354,7 +354,7 @@ EBuildResult DiscBuilderGCN::buildFromDirectory(SystemStringView dirIn) {
if (!m_fileIO->beginWriteStream())
return EBuildResult::Failed;
if (!CheckFreeSpace(m_outPath.c_str(), 0x57058000)) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("not enough free disk space for {}")), m_outPath);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("not enough free disk space for {}")), m_outPath);
return EBuildResult::DiskFull;
}
m_progressCB(getProgressFactor(), _SYS_STR("Preallocating image"), -1);
@ -378,7 +378,7 @@ std::optional<uint64_t> DiscBuilderGCN::CalculateTotalSizeRequired(SystemStringV
return sz;
*sz += 0x30000;
if (sz > 0x57058000) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("disc capacity exceeded [{} / {}]")), *sz, 0x57058000);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("disc capacity exceeded [{} / {}]")), *sz, 0x57058000);
return std::nullopt;
}
return sz;
@ -396,7 +396,7 @@ 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, fmt(_SYS_STR("not enough free disk space for {}")), m_builder.m_outPath);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("not enough free disk space for {}")), m_builder.m_outPath);
return EBuildResult::DiskFull;
}
m_builder.m_progressCB(m_builder.getProgressFactor(), _SYS_STR("Preallocating image"), -1);
@ -422,7 +422,7 @@ std::optional<uint64_t> DiscMergerGCN::CalculateTotalSizeRequired(DiscGCN& sourc
return std::nullopt;
*sz += 0x30000;
if (sz > 0x57058000) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("disc capacity exceeded [{} / {}]")), *sz, 0x57058000);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("disc capacity exceeded [{} / {}]")), *sz, 0x57058000);
return std::nullopt;
}
return sz;

20
lib/DiscIONFS.cpp
View File

@ -71,7 +71,7 @@ public:
fpin.compare(slashPos + 1, 4, _SYS_STR("hif_")) ||
fpin.compare(dotPos, fpin.size() - dotPos, _SYS_STR(".nfs"))) {
LogModule.report(logvisor::Error,
fmt(_SYS_STR("'{}' must begin with 'hif_' and end with '.nfs' to be accepted as an NFS image")), fpin);
FMT_STRING(_SYS_STR("'{}' must begin with 'hif_' and end with '.nfs' to be accepted as an NFS image")), fpin);
err = true;
return;
}
@ -82,32 +82,32 @@ public:
if (!keyFile)
keyFile = NewFileIO(dir + _SYS_STR("htk.bin"))->beginReadStream();
if (!keyFile) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("Unable to open '{}../code/htk.bin' or '{}htk.bin'")), dir, dir);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("Unable to open '{}../code/htk.bin' or '{}htk.bin'")), dir, dir);
err = true;
return;
}
if (keyFile->read(key, 16) != 16) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("Unable to read from '{}../code/htk.bin' or '{}htk.bin'")), dir, dir);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("Unable to read from '{}../code/htk.bin' or '{}htk.bin'")), dir, dir);
err = true;
return;
}
/* Load header from first file */
const SystemString firstPath = fmt::format(fmt(_SYS_STR("{}hif_{:06}.nfs")), dir, 0);
const SystemString firstPath = fmt::format(FMT_STRING(_SYS_STR("{}hif_{:06}.nfs")), dir, 0);
files.push_back(NewFileIO(firstPath));
auto rs = files.back()->beginReadStream();
if (!rs) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("'{}' does not exist")), firstPath);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("'{}' does not exist")), firstPath);
err = true;
return;
}
if (rs->read(&nfsHead, 0x200) != 0x200) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("Unable to read header from '{}'")), firstPath);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("Unable to read header from '{}'")), firstPath);
err = true;
return;
}
if (std::memcmp(&nfsHead.magic, "EGGS", 4)) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("Invalid magic in '{}'")), firstPath);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("Invalid magic in '{}'")), firstPath);
err = true;
return;
}
@ -122,10 +122,10 @@ public:
const uint32_t numFiles = calculateNumFiles();
files.reserve(numFiles);
for (uint32_t i = 1; i < numFiles; ++i) {
SystemString path = fmt::format(fmt(_SYS_STR("{}hif_{:06}.nfs")), dir, i);
SystemString path = fmt::format(FMT_STRING(_SYS_STR("{}hif_{:06}.nfs")), dir, i);
files.push_back(NewFileIO(path));
if (!files.back()->exists()) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("'{}' does not exist")), path);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("'{}' does not exist")), path);
err = true;
return;
}
@ -161,7 +161,7 @@ public:
void setCurFile(uint32_t curFile) {
if (curFile >= m_parent.files.size()) {
LogModule.report(logvisor::Error, fmt("Out of bounds NFS file access"));
LogModule.report(logvisor::Error, FMT_STRING("Out of bounds NFS file access"));
return;
}
m_curFile = curFile;

12
lib/DiscIOWBFS.cpp
View File

@ -76,7 +76,7 @@ class DiscIOWBFS : public IDiscIO {
off *= 512ULL;
rs.seek(off, SEEK_SET);
if (rs.read(buf, count * 512ULL) != count * 512ULL) {
LogModule.report(logvisor::Error, fmt("error reading disc"));
LogModule.report(logvisor::Error, FMT_STRING("error reading disc"));
return 1;
}
return 0;
@ -92,7 +92,7 @@ public:
WBFS* p = &wbfs;
WBFSHead tmpHead;
if (rs->read(&tmpHead, sizeof(tmpHead)) != sizeof(tmpHead)) {
LogModule.report(logvisor::Error, fmt("unable to read WBFS head"));
LogModule.report(logvisor::Error, FMT_STRING("unable to read WBFS head"));
return;
}
unsigned hd_sector_size = 1 << tmpHead.hd_sec_sz_s;
@ -102,7 +102,7 @@ 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, fmt("unable to read WBFS head"));
LogModule.report(logvisor::Error, FMT_STRING("unable to read WBFS head"));
return;
}
@ -115,11 +115,11 @@ public:
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, fmt("hd sector size doesn't match"));
LogModule.report(logvisor::Error, FMT_STRING("hd sector size doesn't match"));
return;
}
if (num_hd_sector && head->n_hd_sec != SBig(num_hd_sector)) {
LogModule.report(logvisor::Error, fmt("hd num sector doesn't match"));
LogModule.report(logvisor::Error, FMT_STRING("hd num sector doesn't match"));
return;
}
p->hd_sec_sz = 1 << head->hd_sec_sz_s;
@ -147,7 +147,7 @@ public:
if (head->disc_table[0]) {
wbfsDiscInfo.reset(new uint8_t[p->disc_info_sz]);
if (!wbfsDiscInfo) {
LogModule.report(logvisor::Error, fmt("allocating memory"));
LogModule.report(logvisor::Error, FMT_STRING("allocating memory"));
return;
}
if (_wbfsReadSector(*rs, p->part_lba + 1, disc_info_sz_lba, wbfsDiscInfo.get()))

46
lib/DiscWii.cpp
View File

@ -421,7 +421,7 @@ public:
uint32_t h3;
if (rs->read(&h3, 4) != 4) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to read H3 offset apploader")));
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to read H3 offset apploader")));
return nullptr;
}
h3 = SBig(h3);
@ -539,7 +539,7 @@ DiscWii::DiscWii(std::unique_ptr<IDiscIO>&& dio, bool& err) : DiscBase(std::move
kind = part.partType;
break;
default:
LogModule.report(logvisor::Error, fmt("invalid partition type {}"), part.partType);
LogModule.report(logvisor::Error, FMT_STRING("invalid partition type {}"), part.partType);
err = true;
return;
}
@ -557,7 +557,7 @@ bool DiscWii::extractDiscHeaderFiles(SystemStringView basePath, const Extraction
SystemString basePathStr(basePath);
if (Mkdir((basePathStr + _SYS_STR("/disc")).c_str(), 0755) && errno != EEXIST) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to mkdir '{}/disc'")), basePathStr);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to mkdir '{}/disc'")), basePathStr);
return false;
}
@ -675,7 +675,7 @@ public:
}
if (m_fio->write(m_buf, 0x200000) != 0x200000) {
LogModule.report(logvisor::Error, fmt("unable to write full disc group"));
LogModule.report(logvisor::Error, FMT_STRING("unable to write full disc group"));
return;
}
}
@ -684,7 +684,7 @@ public:
PartWriteStream(PartitionBuilderWii& parent, uint64_t baseOffset, uint64_t offset, bool& err)
: m_parent(parent), m_baseOffset(baseOffset), m_offset(offset) {
if (offset % 0x1F0000) {
LogModule.report(logvisor::Error, fmt("partition write stream MUST begin on 0x1F0000-aligned boundary"));
LogModule.report(logvisor::Error, FMT_STRING("partition write stream MUST begin on 0x1F0000-aligned boundary"));
err = true;
return;
}
@ -754,13 +754,13 @@ public:
uint64_t userAllocate(uint64_t reqSz, IPartWriteStream& ws) override {
reqSz = ROUND_UP_32(reqSz);
if (m_curUser + reqSz >= 0x1FB450000) {
LogModule.report(logvisor::Error, fmt("partition exceeds maximum single-partition capacity"));
LogModule.report(logvisor::Error, FMT_STRING("partition exceeds maximum single-partition capacity"));
return -1;
}
uint64_t ret = m_curUser;
PartWriteStream& cws = static_cast<PartWriteStream&>(ws);
if (cws.m_offset > ret) {
LogModule.report(logvisor::Error, fmt("partition overwrite error"));
LogModule.report(logvisor::Error, FMT_STRING("partition overwrite error"));
return -1;
}
while (cws.m_offset < ret)
@ -838,7 +838,7 @@ public:
fstSz = ROUND_UP_32(fstSz);
if (fstOff + fstSz >= 0x1F0000) {
LogModule.report(logvisor::Error, fmt("FST flows into user area (one or the other is too big)"));
LogModule.report(logvisor::Error, FMT_STRING("FST flows into user area (one or the other is too big)"));
return -1;
}
@ -854,7 +854,7 @@ public:
size_t fstOffRel = fstOff - 0x2440;
if (xferSz > fstOffRel) {
LogModule.report(logvisor::Error, fmt("apploader unexpectedly flows into FST"));
LogModule.report(logvisor::Error, FMT_STRING("apploader unexpectedly flows into FST"));
return -1;
}
for (size_t i = 0; i < fstOffRel - xferSz; ++i)
@ -938,7 +938,7 @@ public:
SystemString ticketIn = basePath + _SYS_STR("/ticket.bin");
Sstat theStat;
if (Stat(ticketIn.c_str(), &theStat)) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {}")), ticketIn);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), ticketIn);
return -1;
}
@ -946,7 +946,7 @@ public:
SystemString tmdIn = basePath + _SYS_STR("/tmd.bin");
Sstat tmdStat;
if (Stat(tmdIn.c_str(), &tmdStat)) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {}")), tmdIn);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), tmdIn);
return -1;
}
@ -954,7 +954,7 @@ public:
SystemString certIn = basePath + _SYS_STR("/cert.bin");
Sstat certStat;
if (Stat(certIn.c_str(), &certStat)) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {}")), certIn);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), certIn);
return -1;
}
@ -962,7 +962,7 @@ public:
SystemString apploaderIn = basePath + _SYS_STR("/sys/apploader.img");
Sstat apploaderStat;
if (Stat(apploaderIn.c_str(), &apploaderStat)) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {}")), apploaderIn);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), apploaderIn);
return -1;
}
@ -970,7 +970,7 @@ public:
SystemString bootIn = basePath + _SYS_STR("/sys/boot.bin");
Sstat bootStat;
if (Stat(bootIn.c_str(), &bootStat)) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {}")), bootIn);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), bootIn);
return -1;
}
@ -978,7 +978,7 @@ public:
SystemString bi2In = basePath + _SYS_STR("/sys/bi2.bin");
Sstat bi2Stat;
if (Stat(bi2In.c_str(), &bi2Stat)) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {}")), bi2In);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), bi2In);
return -1;
}
@ -1071,7 +1071,7 @@ public:
cws.write(buf, rdSz);
xferSz += rdSz;
if (0x2440 + xferSz >= 0x1F0000) {
LogModule.report(logvisor::Error, fmt("apploader flows into user area (one or the other is too big)"));
LogModule.report(logvisor::Error, FMT_STRING("apploader flows into user area (one or the other is too big)"));
return false;
}
m_parent.m_progressCB(m_parent.getProgressFactor(), apploaderIn, xferSz);
@ -1129,7 +1129,7 @@ public:
cws.write(apploaderBuf.get(), apploaderSz);
xferSz += apploaderSz;
if (0x2440 + xferSz >= 0x1F0000) {
LogModule.report(logvisor::Error, fmt("apploader flows into user area (one or the other is too big)"));
LogModule.report(logvisor::Error, FMT_STRING("apploader flows into user area (one or the other is too big)"));
return false;
}
m_parent.m_progressCB(m_parent.getProgressFactor(), apploaderName, xferSz);
@ -1153,7 +1153,7 @@ EBuildResult DiscBuilderWii::buildFromDirectory(SystemStringView dirIn) {
return EBuildResult::Failed;
if (!CheckFreeSpace(m_outPath.c_str(), m_discCapacity)) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("not enough free disk space for {}")), m_outPath);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("not enough free disk space for {}")), m_outPath);
return EBuildResult::DiskFull;
}
m_progressCB(getProgressFactor(), _SYS_STR("Preallocating image"), -1);
@ -1172,7 +1172,7 @@ EBuildResult DiscBuilderWii::buildFromDirectory(SystemStringView dirIn) {
if (filledSz == UINT64_MAX)
return EBuildResult::Failed;
else if (filledSz >= uint64_t(m_discCapacity)) {
LogModule.report(logvisor::Error, fmt("data partition exceeds disc capacity"));
LogModule.report(logvisor::Error, FMT_STRING("data partition exceeds disc capacity"));
return EBuildResult::Failed;
}
@ -1246,7 +1246,7 @@ std::optional<uint64_t> DiscBuilderWii::CalculateTotalSizeRequired(SystemStringV
*sz += 0x200000;
dualLayer = (sz > 0x118240000);
if (sz > 0x1FB4E0000) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("disc capacity exceeded [{} / {}]")), *sz, 0x1FB4E0000);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("disc capacity exceeded [{} / {}]")), *sz, 0x1FB4E0000);
return std::nullopt;
}
return sz;
@ -1267,7 +1267,7 @@ EBuildResult DiscMergerWii::mergeFromDirectory(SystemStringView dirIn) {
return EBuildResult::Failed;
if (!CheckFreeSpace(m_builder.m_outPath.c_str(), m_builder.m_discCapacity)) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("not enough free disk space for {}")), m_builder.m_outPath);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("not enough free disk space for {}")), m_builder.m_outPath);
return EBuildResult::DiskFull;
}
m_builder.m_progressCB(m_builder.getProgressFactor(), _SYS_STR("Preallocating image"), -1);
@ -1286,7 +1286,7 @@ EBuildResult DiscMergerWii::mergeFromDirectory(SystemStringView dirIn) {
if (filledSz == UINT64_MAX)
return EBuildResult::Failed;
else if (filledSz >= uint64_t(m_builder.m_discCapacity)) {
LogModule.report(logvisor::Error, fmt("data partition exceeds disc capacity"));
LogModule.report(logvisor::Error, FMT_STRING("data partition exceeds disc capacity"));
return EBuildResult::Failed;
}
@ -1353,7 +1353,7 @@ std::optional<uint64_t> DiscMergerWii::CalculateTotalSizeRequired(DiscWii& sourc
*sz += 0x200000;
dualLayer = (sz > 0x118240000);
if (sz > 0x1FB4E0000) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("disc capacity exceeded [{} / {}]")), *sz, 0x1FB4E0000);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("disc capacity exceeded [{} / {}]")), *sz, 0x1FB4E0000);
return std::nullopt;
}
return sz;

12
lib/FileIOFILE.cpp
View File

@ -41,7 +41,7 @@ public:
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);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to open '{}' for writing")), path);
err = true;
}
}
@ -57,14 +57,14 @@ public:
FSeek(fp, offset, SEEK_SET);
return;
FailLoc:
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to open '{}' for writing")), path);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to open '{}' for writing")), path);
err = true;
}
~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")),
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("write operation exceeds file's {}-byte limit")),
m_maxWriteSize);
return 0;
}
@ -99,7 +99,7 @@ public:
fp = Fopen(path.data(), _SYS_STR("rb"));
if (!fp) {
err = true;
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to open '{}' for reading")), path);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to open '{}' for reading")), path);
}
}
ReadStream(SystemStringView path, uint64_t offset, bool& err) : ReadStream(path, err) {
@ -117,11 +117,11 @@ public:
while (length) {
uint64_t thisSz = nod::min(uint64_t(0x7c00), length);
if (read(buf, thisSz) != thisSz) {
LogModule.report(logvisor::Error, fmt("unable to read enough from file"));
LogModule.report(logvisor::Error, FMT_STRING("unable to read enough from file"));
return written;
}
if (discio.write(buf, thisSz) != thisSz) {
LogModule.report(logvisor::Error, fmt("unable to write enough to disc"));
LogModule.report(logvisor::Error, FMT_STRING("unable to write enough to disc"));
return written;
}
length -= thisSz;

12
lib/FileIOWin32.cpp
View File

@ -59,7 +59,7 @@ public:
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);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to open '{}' for writing")), path);
err = true;
}
}
@ -72,7 +72,7 @@ public:
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);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to open '{}' for writing")), path);
err = true;
return;
}
@ -87,7 +87,7 @@ public:
LARGE_INTEGER res;
SetFilePointerEx(fp, li, &res, FILE_CURRENT);
if (res.QuadPart + int64_t(length) > m_maxWriteSize) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("write operation exceeds file's {}-byte limit")),
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("write operation exceeds file's {}-byte limit")),
m_maxWriteSize);
return 0;
}
@ -130,7 +130,7 @@ public:
#endif
if (fp == INVALID_HANDLE_VALUE) {
err = true;
LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to open '{}' for reading")), path);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to open '{}' for reading")), path);
}
}
ReadStream(SystemStringView path, uint64_t offset, bool& err) : ReadStream(path, err) {
@ -163,11 +163,11 @@ public:
while (length) {
uint64_t thisSz = nod::min(uint64_t(0x7c00), length);
if (read(buf, thisSz) != thisSz) {
LogModule.report(logvisor::Error, fmt("unable to read enough from file"));
LogModule.report(logvisor::Error, FMT_STRING("unable to read enough from file"));
return written;
}
if (discio.write(buf, thisSz) != thisSz) {
LogModule.report(logvisor::Error, fmt("unable to write enough to disc"));
LogModule.report(logvisor::Error, FMT_STRING("unable to write enough to disc"));
return written;
}
length -= thisSz;

6
lib/nod.cpp
View File

@ -18,7 +18,7 @@ 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, fmt(_SYS_STR("Unable to open '{}'")), path);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("Unable to open '{}'")), path);
return {};
}
std::unique_ptr<IFileIO::IReadStream> rs = fio->beginReadStream();
@ -29,7 +29,7 @@ std::unique_ptr<DiscBase> OpenDiscFromImage(SystemStringView path, bool& isWii)
std::unique_ptr<IDiscIO> discIO;
uint32_t magic = 0;
if (rs->read(&magic, 4) != 4) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("Unable to read magic from '{}'")), path);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("Unable to read magic from '{}'")), path);
return {};
}
@ -60,7 +60,7 @@ std::unique_ptr<DiscBase> OpenDiscFromImage(SystemStringView path, bool& isWii)
}
if (!discIO) {
LogModule.report(logvisor::Error, fmt(_SYS_STR("'{}' is not a valid image")), path);
LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("'{}' is not a valid image")), path);
return {};
}

2
logvisor

@ -1 +1 @@
Subproject commit 27814c527622538d384336c4d43cf5b4b6869859
Subproject commit d62b4ce26e4eb7f70126173a10a58bc858fecc02