drinkingtea/jasper
2
0
Fork 0
Code Issues 2 Pull Requests Actions Releases Activity

Squashed 'deps/nostalgia/' changes from 161640fa..a75c4a11

Browse Source 
a75c4a11 [nfde] Address CMake warning, remove unwanted logging
347a1657 [sample_project] Update type descriptors
fd64bfae [keel] Fix a use after free, cleanup
aaeec20a [nostalgia/player] Fix build
37030f9c [keel] Cleanup pack tool
462f2bca [nostalgia,olympic] Change macro names to comply with broader conventions
dc72500b [glutils] Change macro names to comply with broader conventions
962fe8bc [ox] Change macro names to comply with broader conventions
305eb626 [studio] Fix build
4754359a [ox/std] Cleanup Vec2
dc07f3d5 [studio] Change FilePicker consturctor to take StringParams
fcdcfd10 [ox/std] Run liccor
b74f6a7a [studio,turbine] Run liccor
ac7e5be1 [ox] Remove OxException
ed910c0b [nostalgia/core/studio/tilesheeteditor] Fix access overflow on out of bounds Fill command
345fb038 [ox] Remove OxError
9881253f [glutils] Cleanup OxError
96d27eec [nostalgia,olympic] Cleanup
28ebe93b [ox/std] Make source_location::current only init if valid
e849e7a3 [ox/std] Add source_location
e6777b0a [cityhash] Add install rule
c488c336 [turbine/glfw] Fix mandatoryRefreshPeriodEnd tracking
003f9720 [turbine/glfw] Move MandatoryRefreshPeriod to config.hpp
d85a10af [nostalgia/core/studio] Cleanup
ff05d860 [turbine/glfw] Replace uninterruptedRefreshes with mandatoryRefreshPeriodEnd
76794037 [turbine] Add init wrapper that takes FS path
c51a45e1 [olympic] Cleanup
a6e24ff2 [ox/std] Add CString type alias
e0ec9e0c [nostalgia,olympic] Move olympic::run to global namespace
9a42a9b9 [nfde] Fix Windows warnings
03a05c51 Merge commit '4ccdfc3a6e5bd501968903a01f7d8141b6f88375'
bd91137d [nostalgia,olympic] Fix pack tool build for Windows
2b7d1294 [nostalgia/core/studio] Fix MSVC build

git-subtree-dir: deps/nostalgia
git-subtree-split: a75c4a11d3c555f4d3bed1ea1f70bb29fe49e99c
This commit is contained in:
Gary Talent
2024-12-21 20:13:20 -06:00
parent 4ccdfc3a6e
commit dc96270ca5
199 changed files with 2468 additions and 2156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/olympic/keel/include/keel/asset.hpp
View File

@@ -16,8 +16,8 @@ constexpr auto K1HdrSz = 40;
ox::Result<ox::UUID> readUuidHeader(ox::BufferView buff) noexcept;
ox::Error writeUuidHeader(ox::Writer_c auto &writer, ox::UUID const&uuid) noexcept {
oxReturnError(write(writer, "K1;"));
oxReturnError(uuid.toString(writer));
OX_RETURN_ERROR(write(writer, "K1;"));
OX_RETURN_ERROR(uuid.toString(writer));
return writer.put(';');
}
@@ -29,8 +29,8 @@ ox::Result<T> readAsset(ox::BufferView buff) noexcept {
offset = K1HdrSz; // the size of K1 headers
}
auto out = ox::readClaw<T>(buff + offset);
oxReturnError(out);
oxReturnError(ensureValid(out.value));
OX_RETURN_ERROR(out);
OX_RETURN_ERROR(ensureValid(out.value));
return out;
}

18
src/olympic/keel/include/keel/assetmanager.hpp
View File

@@ -155,7 +155,7 @@ class AssetRef: public ox::SignalHandler {
private:
constexpr ox::Error emitUpdated() const noexcept {
updated.emit();
return OxError(0);
return ox::Error(0);
}
};
@@ -205,16 +205,16 @@ class AssetManager {
AssetTypeManager(Loader loader) noexcept: m_loader(loader) {}
ox::Result<AssetRef<T>> getAsset(ox::StringView const assetId) const noexcept {
oxRequire(out, m_cache.at(assetId));
OX_REQUIRE(out, m_cache.at(assetId));
if (!out || !*out) {
return OxError(1, "asset is null");
return ox::Error(1, "asset is null");
}
return AssetRef<T>(out->get());
}
ox::Result<AssetRef<T>> loadAsset(ox::StringView const assetId) noexcept {
auto &p = m_cache[assetId];
oxRequireM(obj, m_loader(assetId));
OX_REQUIRE_M(obj, m_loader(assetId));
if (!p) {
p = ox::make_unique<AssetContainer<T>>(std::move(obj));
} else {
@@ -226,7 +226,7 @@ class AssetManager {
ox::Error reloadAsset(ox::StringView const assetId) noexcept {
auto &p = m_cache[assetId];
oxRequireM(obj, m_loader(assetId));
OX_REQUIRE_M(obj, m_loader(assetId));
if (!p) {
p = ox::make_unique<AssetContainer<T>>(std::move(obj));
} else {
@@ -256,7 +256,7 @@ class AssetManager {
auto &am = m_assetTypeManagers[typeId];
auto const out = dynamic_cast<AssetTypeManager<T>*>(am.get());
if (!out) {
return OxError(1, "no AssetTypeManager for type");
return ox::Error(1, "no AssetTypeManager for type");
}
return out;
}
@@ -274,7 +274,7 @@ class AssetManager {
template<typename T>
ox::Result<AssetRef<T>> getAsset(ox::StringView assetId) noexcept {
oxRequire(m, getTypeManager<T>());
OX_REQUIRE(m, getTypeManager<T>());
return m->getAsset(assetId);
}
@@ -285,8 +285,8 @@ class AssetManager {
template<typename T>
ox::Result<AssetRef<T>> loadAsset(ox::StringView assetId) noexcept {
oxRequire(m, getTypeManager<T>());
oxRequire(out, m->loadAsset(assetId));
OX_REQUIRE(m, getTypeManager<T>());
OX_REQUIRE(out, m->loadAsset(assetId));
m_fileUpdated[assetId].connect(m, &AssetTypeManager<T>::reloadAsset);
return out;
}

77
src/olympic/keel/include/keel/media.hpp
View File

@@ -25,15 +25,15 @@ struct PreloadPtr {
uint64_t preloadAddr = 0;
};
oxModelBegin(PreloadPtr)
oxModelField(preloadAddr)
oxModelEnd()
OX_MODEL_BEGIN(PreloadPtr)
OX_MODEL_FIELD(preloadAddr)
OX_MODEL_END()
ox::Result<std::size_t> getPreloadAddr(keel::Context &ctx, ox::FileAddress const&addr) noexcept;
ox::Result<std::size_t> getPreloadAddr(keel::Context &ctx, ox::StringViewCR path) noexcept;
void createUuidMapping(Context &ctx, ox::StringView filePath, ox::UUID const&uuid) noexcept;
void createUuidMapping(Context &ctx, ox::StringViewCR filePath, ox::UUID const&uuid) noexcept;
ox::Error buildUuidMap(Context &ctx) noexcept;
@@ -41,17 +41,17 @@ ox::Result<ox::UUID> pathToUuid(Context &ctx, ox::StringViewCR path) noexcept;
ox::Result<ox::UUID> getUuid(Context &ctx, ox::FileAddress const&fileAddr) noexcept;
ox::Result<ox::UUID> getUuid(Context &ctx, ox::StringView path) noexcept;
ox::Result<ox::UUID> getUuid(Context &ctx, ox::StringViewCR path) noexcept;
ox::Result<ox::CStringView> getPath(Context &ctx, ox::FileAddress const&fileAddr) noexcept;
ox::Result<ox::CStringView> getPath(Context &ctx, ox::CStringView fileId) noexcept;
ox::Result<ox::CStringView> getPath(Context &ctx, ox::CStringViewCR fileId) noexcept;
constexpr ox::Result<ox::UUID> uuidUrlToUuid(ox::StringView uuidUrl) noexcept {
constexpr ox::Result<ox::UUID> uuidUrlToUuid(ox::StringViewCR uuidUrl) noexcept {
return ox::UUID::fromString(substr(uuidUrl, 7));
}
ox::Result<ox::CStringView> uuidUrlToPath(Context &ctx, ox::StringView uuid) noexcept;
ox::Result<ox::CStringView> uuidUrlToPath(Context &ctx, ox::StringViewCR uuid) noexcept;
ox::Result<ox::CStringView> uuidToPath(Context &ctx, ox::StringViewCR uuid) noexcept;
@@ -62,15 +62,15 @@ ox::Result<ox::CStringView> uuidToPath(Context &ctx, ox::UUID const&uuid) noexce
namespace detail {
template<typename T>
constexpr auto makeLoader(Context &ctx) {
return [&ctx](ox::StringView assetId) -> ox::Result<T> {
oxRequire(p, ctx.uuidToPath.at(assetId));
oxRequire(buff, ctx.rom->read(*p));
return [&ctx](ox::StringViewCR assetId) -> ox::Result<T> {
OX_REQUIRE(p, ctx.uuidToPath.at(assetId));
OX_REQUIRE(buff, ctx.rom->read(*p));
auto [obj, err] = readAsset<T>(buff);
if (err) {
if (err != ox::Error_ClawTypeVersionMismatch && err != ox::Error_ClawTypeMismatch) {
return err;
}
oxReturnError(convert<T>(ctx, buff, &obj));
OX_RETURN_ERROR(convert<T>(ctx, buff, &obj));
}
return std::move(obj);
};
@@ -80,27 +80,34 @@ constexpr auto makeLoader(Context &ctx) {
template<typename T>
ox::Result<keel::AssetRef<T>> readObjFile(
keel::Context &ctx,
ox::StringView assetId,
bool forceLoad) noexcept {
ox::StringViewCR assetId,
bool const forceLoad) noexcept {
static constexpr auto load = [](
keel::Context &ctx,
ox::StringViewCR assetId,
bool forceLoad) -> ox::Result<keel::AssetRef<T>> {
if (forceLoad) {
ctx.assetManager.initTypeManager<T>(detail::makeLoader<T>, ctx);
return ctx.assetManager.loadAsset<T>(assetId);
} else {
auto [cached, err] = ctx.assetManager.getAsset<T>(assetId);
if (err) {
ctx.assetManager.initTypeManager<T>(detail::makeLoader<T>, ctx);
OX_RETURN_ERROR(ctx.assetManager.loadAsset<T>(assetId).moveTo(cached));
}
return cached;
}
};
if (beginsWith(assetId, "uuid://")) {
assetId = substr(assetId, 7);
return load(ctx, substr(assetId, 7), forceLoad);
} else {
auto const [uuid, uuidErr] = getUuid(ctx, assetId);
if (!uuidErr) {
assetId = uuid.toString();
return load(ctx, uuid.toString(), forceLoad);
} else {
return load(ctx, assetId, forceLoad);
}
}
if (forceLoad) {
ctx.assetManager.initTypeManager<T>(detail::makeLoader<T>, ctx);
return ctx.assetManager.loadAsset<T>(assetId);
} else {
auto [cached, err] = ctx.assetManager.getAsset<T>(assetId);
if (err) {
ctx.assetManager.initTypeManager<T>(detail::makeLoader<T>, ctx);
oxReturnError(ctx.assetManager.loadAsset<T>(assetId).moveTo(cached));
}
return cached;
}
}
#else
@@ -110,16 +117,16 @@ ox::Result<keel::AssetRef<T>> readObjNoCache(
keel::Context &ctx,
ox::StringViewCR assetId) noexcept {
if constexpr(ox::preloadable<T>::value) {
oxRequire(addr, getPreloadAddr(ctx, assetId));
OX_REQUIRE(addr, getPreloadAddr(ctx, assetId));
return keel::AssetRef<T>(std::bit_cast<T const*>(uintptr_t{addr}));
} else {
return OxError(1);
return ox::Error(1);
}
}
#endif
ox::Error reloadAsset(keel::Context &ctx, ox::StringView assetId) noexcept;
ox::Error reloadAsset(keel::Context &ctx, ox::StringViewCR assetId) noexcept;
template<typename T>
ox::Result<keel::AssetRef<T>> readObj(
@@ -139,14 +146,14 @@ ox::Result<keel::AssetRef<T>> readObj(
ox::FileAddress const&file,
[[maybe_unused]] bool forceLoad = false) noexcept {
#ifndef OX_BARE_METAL
oxRequire(assetId, file.getPath());
OX_REQUIRE(assetId, file.getPath());
return readObj<T>(ctx, ox::StringView(assetId), forceLoad);
#else
if constexpr(ox::preloadable<T>::value) {
oxRequire(addr, getPreloadAddr(ctx, file));
OX_REQUIRE(addr, getPreloadAddr(ctx, file));
return keel::AssetRef<T>(std::bit_cast<T const*>(uintptr_t{addr}));
} else {
return OxError(1);
return ox::Error(1);
}
#endif
}
@@ -157,13 +164,13 @@ ox::Error writeObj(
ox::FileAddress const&file,
T const&obj,
ox::ClawFormat fmt = ox::ClawFormat::Metal) noexcept {
oxRequire(objBuff, ox::writeClaw(obj, fmt));
OX_REQUIRE(objBuff, ox::writeClaw(obj, fmt));
return ctx.rom->write(file, objBuff.data(), objBuff.size());
}
ox::Error setRomFs(Context &ctx, ox::UPtr<ox::FileSystem> &&fs) noexcept;
ox::Result<ox::UniquePtr<ox::FileSystem>> loadRomFs(ox::StringViewCR path) noexcept;
ox::Result<ox::UPtr<ox::FileSystem>> loadRomFs(ox::StringViewCR path) noexcept;
ox::Result<char*> loadRom(ox::StringViewCR path = "") noexcept;

52
src/olympic/keel/include/keel/pack.hpp
View File

@@ -20,11 +20,11 @@ struct ManifestEntry {
ox::String type;
};
oxModelBegin(ManifestEntry)
oxModelField(inode)
oxModelField(preloaded)
oxModelField(type)
oxModelEnd()
OX_MODEL_BEGIN(ManifestEntry)
OX_MODEL_FIELD(inode)
OX_MODEL_FIELD(preloaded)
OX_MODEL_FIELD(type)
OX_MODEL_END()
struct Manifest {
static constexpr auto TypeName = "net.drinkingtea.keel.Manifest";
@@ -32,9 +32,9 @@ struct Manifest {
ox::HashMap<ox::String, ManifestEntry> files;
};
oxModelBegin(Manifest)
oxModelField(files)
oxModelEnd()
OX_MODEL_BEGIN(Manifest)
OX_MODEL_FIELD(files)
OX_MODEL_END()
class Context;
@@ -113,24 +113,24 @@ ox::Error preloadObj(
ox::Preloader<PlatSpec> &pl,
ox::StringView const path) noexcept {
// load file
oxRequireM(buff, romFs.read(path));
oxRequireM(obj, keel::readAsset(ts, buff));
OX_REQUIRE_M(buff, romFs.read(path));
OX_REQUIRE_M(obj, keel::readAsset(ts, buff));
if (obj.type()->preloadable) {
// preload
auto const size = ox::sizeOf<GbaPlatSpec>(&obj);
auto const alignment = ox::alignOf<GbaPlatSpec>(obj);
oxRequire(a, pl.startAlloc(size, alignment));
OX_REQUIRE(a, pl.startAlloc(size, alignment));
auto const err = ox::preload<GbaPlatSpec, ox::ModelObject>(&pl, &obj);
oxReturnError(pl.endAlloc());
oxReturnError(err);
OX_RETURN_ERROR(pl.endAlloc());
OX_RETURN_ERROR(err);
keel::PreloadPtr const p{.preloadAddr = a};
oxReturnError(ox::writeMC(p).moveTo(buff));
OX_RETURN_ERROR(ox::writeMC(p).moveTo(buff));
oxOutf("preloaded {} as a {} @ {} to {}\n", path, obj.type()->typeName, a, a + size);
} else {
// strip the Claw header (it is not needed after preloading) and write back out to dest fs
oxReturnError(ox::writeMC(obj).moveTo(buff));
OX_RETURN_ERROR(ox::writeMC(obj).moveTo(buff));
}
oxReturnError(romFs.write(path, buff.data(), buff.size()));
OX_RETURN_ERROR(romFs.write(path, buff.data(), buff.size()));
return {};
}
@@ -145,13 +145,13 @@ ox::Error preloadDir(
ox::StringViewCR path) noexcept {
// copy
oxTracef("pack.preload", "path: {}", path);
oxRequire(fileList, romFs.ls(path));
OX_REQUIRE(fileList, romFs.ls(path));
for (auto const&name : fileList) {
auto const filePath = ox::sfmt("{}{}", path, name);
oxRequire(stat, romFs.stat(filePath));
OX_REQUIRE(stat, romFs.stat(filePath));
if (stat.fileType == ox::FileType::Directory) {
auto const dir = ox::sfmt("{}{}/", path, name);
oxReturnError(preloadDir(manifest, ts, romFs, pl, dir));
OX_RETURN_ERROR(preloadDir(manifest, ts, romFs, pl, dir));
} else {
auto const err = preloadObj(ts, romFs, pl, filePath);
if (err) {
@@ -177,14 +177,14 @@ ox::Error appendBinary(ox::Buffer &binBuff, ox::SpanView<char> const&fsBuff, ox:
static_assert(mediaHdr.bytes() == hdrSize);
static_assert(preloadHdr.bytes() == hdrSize);
ox::BufferWriter w(&binBuff);
oxReturnError(padbin(w, hdrSize));
oxReturnError(w.write(mediaHdr.data(), mediaHdr.bytes()));
oxReturnError(w.write(fsBuff.data(), fsBuff.size()));
oxReturnError(padbin(w, hdrSize));
oxReturnError(w.write(preloadHdr.data(), preloadHdr.bytes()));
oxReturnError(pl.offsetPtrs(binBuff.size()));
OX_RETURN_ERROR(padbin(w, hdrSize));
OX_RETURN_ERROR(w.write(mediaHdr.data(), mediaHdr.bytes()));
OX_RETURN_ERROR(w.write(fsBuff.data(), fsBuff.size()));
OX_RETURN_ERROR(padbin(w, hdrSize));
OX_RETURN_ERROR(w.write(preloadHdr.data(), preloadHdr.bytes()));
OX_RETURN_ERROR(pl.offsetPtrs(binBuff.size()));
auto const&plBuff = pl.buff();
oxReturnError(w.write(plBuff.data(), plBuff.size()));
OX_RETURN_ERROR(w.write(plBuff.data(), plBuff.size()));
return {};
}

14
src/olympic/keel/include/keel/typeconv.hpp
View File

@@ -110,15 +110,15 @@ class Converter: public BaseConverter {
ox::Result<ox::UPtr<Wrap>> convertPtrToPtr(
keel::Context &ctx, Wrap &src) const noexcept final {
auto dst = makeWrap<DstType>();
oxReturnError(convert(ctx, wrapCast<SrcType>(src), wrapCast<DstType>(*dst)));
OX_RETURN_ERROR(convert(ctx, wrapCast<SrcType>(src), wrapCast<DstType>(*dst)));
return {std::move(dst)};
}
ox::Result<ox::UPtr<Wrap>> convertBuffToPtr(
keel::Context &ctx, ox::BufferView const&srcBuff) const noexcept final {
oxRequireM(src, readAsset<SrcType>(srcBuff));
OX_REQUIRE_M(src, readAsset<SrcType>(srcBuff));
auto dst = makeWrap<DstType>();
oxReturnError(convert(ctx, src, wrapCast<DstType>(*dst)));
OX_RETURN_ERROR(convert(ctx, src, wrapCast<DstType>(*dst)));
return {std::move(dst)};
}
@@ -137,7 +137,7 @@ template<typename DstType>
ox::Result<DstType> convert(keel::Context &ctx, ox::BufferView const&srcBuffer) noexcept {
static constexpr auto DstTypeName = ox::requireModelTypeName<DstType>();
static constexpr auto DstTypeVersion = ox::requireModelTypeVersion<DstType>();
oxRequire(out, convert(ctx, srcBuffer, DstTypeName, DstTypeVersion));
OX_REQUIRE(out, convert(ctx, srcBuffer, DstTypeName, DstTypeVersion));
return std::move(wrapCast<DstType>(out));
}
@@ -145,7 +145,7 @@ template<typename DstType>
ox::Error convert(keel::Context &ctx, ox::BufferView const&buff, DstType *outObj) noexcept {
static constexpr auto DstTypeName = ox::requireModelTypeName<DstType>();
static constexpr auto DstTypeVersion = ox::requireModelTypeVersion<DstType>();
oxRequire(outPtr, convert(ctx, buff, DstTypeName, DstTypeVersion));
OX_REQUIRE(outPtr, convert(ctx, buff, DstTypeName, DstTypeVersion));
*outObj = std::move(wrapCast<DstType>(*outPtr));
return {};
}
@@ -155,14 +155,14 @@ ox::Result<ox::Buffer> convertBuffToBuff(
keel::Context &ctx, ox::BufferView const&srcBuffer, ox::ClawFormat fmt) noexcept {
static constexpr auto DstTypeName = ox::requireModelTypeName<DstType>();
static constexpr auto DstTypeVersion = ox::requireModelTypeVersion<DstType>();
oxRequire(out, convert(ctx, srcBuffer, DstTypeName, DstTypeVersion));
OX_REQUIRE(out, convert(ctx, srcBuffer, DstTypeName, DstTypeVersion));
return ox::writeClaw<DstType>(wrapCast<DstType>(*out), fmt);
}
template<typename From, typename To, ox::ClawFormat fmt = ox::ClawFormat::Metal>
ox::Result<bool> transformRule(keel::Context &ctx, ox::Buffer &buff, ox::StringView typeId) noexcept {
if (typeId == ox::ModelTypeId_v<From>) {
oxReturnError(keel::convertBuffToBuff<To>(ctx, buff, fmt).moveTo(buff));
OX_RETURN_ERROR(keel::convertBuffToBuff<To>(ctx, buff, fmt).moveTo(buff));
return true;
}
return false;

2
src/olympic/keel/include/keel/validation.hpp
View File

@@ -14,7 +14,7 @@ constexpr bool valid(auto const&) noexcept {
}
constexpr ox::Error repair(auto const&) noexcept {
return OxError(1, "No repair function for this type");
return ox::Error(1, "No repair function for this type");
}
constexpr ox::Error ensureValid(auto &o) noexcept {

10
src/olympic/keel/src/asset.cpp
View File

@@ -8,11 +8,11 @@ namespace keel {
ox::Result<ox::UUID> readUuidHeader(ox::BufferView buff) noexcept {
if (buff.size() < K1HdrSz) [[unlikely]] {
return OxError(1, "Insufficient data to contain complete Keel header");
return ox::Error(1, "Insufficient data to contain complete Keel header");
}
constexpr ox::StringView k1Hdr = "K1;";
if (k1Hdr != ox::StringView(buff.data(), k1Hdr.bytes())) [[unlikely]] {
return OxError(2, "No Keel asset header data");
return ox::Error(2, "No Keel asset header data");
}
return ox::UUID::fromString(ox::StringView(&buff[k1Hdr.bytes()], 36));
}
@@ -30,7 +30,7 @@ ox::Result<ox::StringView> readAssetTypeId(ox::BufferView buff) noexcept {
const auto err = readUuidHeader(buff).error;
const auto offset = err ? 0u : K1HdrSz;
if (offset >= buff.size()) [[unlikely]] {
return OxError(1, "Buffer too small for expected data");
return ox::Error(1, "Buffer too small for expected data");
}
return ox::readClawTypeId(buff + offset);
}
@@ -40,10 +40,10 @@ ox::Result<AssetHdr> readAssetHeader(ox::BufferView buff) noexcept {
const auto err = readUuidHeader(buff).moveTo(out.value.uuid);
const auto offset = err ? 0u : K1HdrSz;
if (offset >= buff.size()) [[unlikely]] {
return OxError(1, "Buffer too small for expected data");
return ox::Error(1, "Buffer too small for expected data");
}
buff += offset;
oxReturnError(ox::readClawHeader(buff).moveTo(out.value.clawHdr));
OX_RETURN_ERROR(ox::readClawHeader(buff).moveTo(out.value.clawHdr));
return out;
}

2
src/olympic/keel/src/keel.cpp
View File

@@ -30,7 +30,7 @@ ox::Error init(
ox::Result<ox::UPtr<Context>> init(ox::UPtr<ox::FileSystem> &&fs, ox::StringViewCR appName) noexcept {
auto ctx = ox::make_unique<Context>();
oxReturnError(keel::init(*ctx, std::move(fs), appName));
OX_RETURN_ERROR(keel::init(*ctx, std::move(fs), appName));
return ctx;
}

88
src/olympic/keel/src/media.cpp
View File

@@ -16,7 +16,7 @@ ox::Result<char*> loadRom(ox::StringViewCR path) noexcept {
std::ifstream file(std::string(toStdStringView(path)), std::ios::binary | std::ios::ate);
if (!file.good()) {
oxErrorf("Could not find ROM file: {}", path);
return OxError(1, "Could not find ROM file");
return ox::Error(1, "Could not find ROM file");
}
try {
auto const size = file.tellg();
@@ -26,10 +26,10 @@ ox::Result<char*> loadRom(ox::StringViewCR path) noexcept {
return buff;
} catch (std::ios_base::failure const&e) {
oxErrorf("Could not read ROM file due to file IO failure: {}", e.what());
return OxError(2, "Could not read ROM file");
return ox::Error(2, "Could not read ROM file");
} catch (std::bad_alloc const&e) {
oxErrorf("Could not read ROM file due to new failure: {}", e.what());
return OxError(2, "Could not allocate memory for ROM file");
return ox::Error(2, "Could not allocate memory for ROM file");
}
}
@@ -42,25 +42,25 @@ static void clearUuidMap(Context &ctx) noexcept {
ctx.pathToUuid.clear();
}
void createUuidMapping(Context &ctx, ox::StringView filePath, ox::UUID const&uuid) noexcept {
void createUuidMapping(Context &ctx, ox::StringViewCR filePath, ox::UUID const&uuid) noexcept {
ctx.pathToUuid[filePath] = uuid;
ctx.uuidToPath[uuid.toString()] = filePath;
}
static ox::Error buildUuidMap(Context &ctx, ox::StringViewCR path) noexcept {
oxRequire(files, ctx.rom->ls(path));
OX_REQUIRE(files, ctx.rom->ls(path));
for (auto const&f : files) {
oxRequireM(filePath, ox::join("/", ox::Array<ox::StringView, 2>{path, f}));
oxRequire(stat, ctx.rom->stat(filePath));
OX_REQUIRE_M(filePath, ox::join("/", ox::Array<ox::StringView, 2>{path, f}));
OX_REQUIRE(stat, ctx.rom->stat(filePath));
if (stat.fileType == ox::FileType::NormalFile) {
oxRequire(data, ctx.rom->read(filePath));
OX_REQUIRE(data, ctx.rom->read(filePath));
auto const [hdr, err] = readAssetHeader(data);
if (!err) {
createUuidMapping(ctx, filePath, hdr.uuid);
}
} else if (stat.fileType == ox::FileType::Directory) {
if (!beginsWith(f, ".")) {
oxReturnError(buildUuidMap(ctx, filePath));
OX_RETURN_ERROR(buildUuidMap(ctx, filePath));
}
}
}
@@ -69,26 +69,26 @@ static ox::Error buildUuidMap(Context &ctx, ox::StringViewCR path) noexcept {
ox::Error buildUuidMap(Context &ctx) noexcept {
if (!ctx.rom) {
return OxError(1, "No ROM FS");
return ox::Error(1, "No ROM FS");
}
return buildUuidMap(ctx, "");
}
ox::Result<ox::UUID> pathToUuid(Context &ctx, ox::StringViewCR path) noexcept {
#ifndef OX_BARE_METAL
oxRequire(out, ctx.pathToUuid.at(path));
OX_REQUIRE(out, ctx.pathToUuid.at(path));
return *out;
#else
return OxError(1, "UUID to path conversion not supported on this platform");
return ox::Error(1, "UUID to path conversion not supported on this platform");
#endif
}
ox::Result<ox::UUID> getUuid(Context &ctx, ox::FileAddress const&fileAddr) noexcept {
oxRequire(path, fileAddr.getPath());
OX_REQUIRE(path, fileAddr.getPath());
return getUuid(ctx, path);
}
ox::Result<ox::UUID> getUuid(Context &ctx, ox::StringView path) noexcept {
ox::Result<ox::UUID> getUuid(Context &ctx, ox::StringViewCR path) noexcept {
if (beginsWith(path, "uuid://")) {
auto const uuid = substr(path, 7);
return ox::UUID::fromString(uuid);
@@ -98,75 +98,73 @@ ox::Result<ox::UUID> getUuid(Context &ctx, ox::StringView path) noexcept {
}
ox::Result<ox::CStringView> getPath(Context &ctx, ox::FileAddress const&fileAddr) noexcept {
oxRequire(path, fileAddr.getPath());
OX_REQUIRE(path, fileAddr.getPath());
if (beginsWith(path, "uuid://")) {
auto const uuid = substr(path, 7);
#ifndef OX_BARE_METAL
oxRequireM(out, ctx.uuidToPath.at(uuid));
OX_REQUIRE_M(out, ctx.uuidToPath.at(uuid));
return ox::CStringView{*out};
#else
return OxError(1, "UUID to path conversion not supported on this platform");
return ox::Error(1, "UUID to path conversion not supported on this platform");
#endif
} else {
return ox::CStringView{path};
}
}
ox::Result<ox::CStringView> getPath(Context &ctx, ox::CStringView fileId) noexcept {
ox::Result<ox::CStringView> getPath(Context &ctx, ox::CStringViewCR fileId) noexcept {
if (beginsWith(fileId, "uuid://")) {
auto const uuid = substr(fileId, 7);
#ifndef OX_BARE_METAL
oxRequireM(out, ctx.uuidToPath.at(uuid));
OX_REQUIRE_M(out, ctx.uuidToPath.at(uuid));
return ox::CStringView{*out};
#else
return OxError(1, "UUID to path conversion not supported on this platform");
return ox::Error(1, "UUID to path conversion not supported on this platform");
#endif
} else {
return ox::CStringView{fileId};
}
}
ox::Result<ox::CStringView> uuidUrlToPath(Context &ctx, ox::StringView uuid) noexcept {
uuid = substr(uuid, 7);
ox::Result<ox::CStringView> uuidUrlToPath(Context &ctx, ox::StringViewCR uuid) noexcept {
#ifndef OX_BARE_METAL
oxRequireM(out, ctx.uuidToPath.at(uuid));
OX_REQUIRE_M(out, ctx.uuidToPath.at(substr(uuid, 7)));
return ox::CStringView(*out);
#else
return OxError(1, "UUID to path conversion not supported on this platform");
return ox::Error(1, "UUID to path conversion not supported on this platform");
#endif
}
ox::Result<ox::CStringView> uuidToPath(Context &ctx, ox::StringViewCR uuid) noexcept {
#ifndef OX_BARE_METAL
oxRequireM(out, ctx.uuidToPath.at(uuid));
OX_REQUIRE_M(out, ctx.uuidToPath.at(uuid));
return ox::CStringView(*out);
#else
return OxError(1, "UUID to path conversion not supported on this platform");
return ox::Error(1, "UUID to path conversion not supported on this platform");
#endif
}
ox::Result<ox::CStringView> uuidToPath(Context &ctx, ox::UUID const&uuid) noexcept {
#ifndef OX_BARE_METAL
oxRequireM(out, ctx.uuidToPath.at(uuid.toString()));
OX_REQUIRE_M(out, ctx.uuidToPath.at(uuid.toString()));
return ox::CStringView(*out);
#else
return OxError(1, "UUID to path conversion not supported on this platform");
return ox::Error(1, "UUID to path conversion not supported on this platform");
#endif
}
ox::Error reloadAsset(keel::Context &ctx, ox::StringView assetId) noexcept {
ox::Error reloadAsset(keel::Context &ctx, ox::StringViewCR assetId) noexcept {
ox::UUIDStr uuidStr;
if (beginsWith(assetId, "uuid://")) {
assetId = substr(assetId, 7);
oxRequire(p, keel::uuidToPath(ctx, assetId));
return ctx.assetManager.reloadAsset(substr(assetId, 7));
} else {
auto const [uuid, uuidErr] = getUuid(ctx, assetId);
if (!uuidErr) {
uuidStr = uuid.toString();
assetId = uuidStr;
return ctx.assetManager.reloadAsset(uuidStr);
} else {
return ctx.assetManager.reloadAsset(assetId);
}
}
return ctx.assetManager.reloadAsset(assetId);
}
}
@@ -200,30 +198,30 @@ ox::Result<char*> loadRom(ox::StringViewCR) noexcept {
return current + headerLen;
}
}
return OxError(1);
return ox::Error(1);
}
void unloadRom(char*) noexcept {
}
ox::Result<std::size_t> getPreloadAddr(keel::Context &ctx, ox::StringViewCR path) noexcept {
oxRequire(stat, ctx.rom->stat(path));
oxRequire(buff, static_cast<ox::MemFS&>(*ctx.rom).directAccess(path));
OX_REQUIRE(stat, ctx.rom->stat(path));
OX_REQUIRE(buff, static_cast<ox::MemFS&>(*ctx.rom).directAccess(path));
PreloadPtr p;
oxReturnError(ox::readMC({buff, static_cast<std::size_t>(stat.size)}, p));
OX_RETURN_ERROR(ox::readMC({buff, static_cast<std::size_t>(stat.size)}, p));
return static_cast<std::size_t>(p.preloadAddr) + ctx.preloadSectionOffset;
}
ox::Result<std::size_t> getPreloadAddr(keel::Context &ctx, ox::FileAddress const&addr) noexcept {
oxRequire(stat, ctx.rom->stat(addr));
oxRequire(buff, static_cast<ox::MemFS&>(*ctx.rom).directAccess(addr));
OX_REQUIRE(stat, ctx.rom->stat(addr));
OX_REQUIRE(buff, static_cast<ox::MemFS&>(*ctx.rom).directAccess(addr));
PreloadPtr p;
oxReturnError(ox::readMC({buff, static_cast<std::size_t>(stat.size)}, p));
OX_RETURN_ERROR(ox::readMC({buff, static_cast<std::size_t>(stat.size)}, p));
return static_cast<std::size_t>(p.preloadAddr) + ctx.preloadSectionOffset;
}
ox::Error reloadAsset(keel::Context&, ox::StringView) noexcept {
return OxError(1, "reloadAsset is unsupported on this platform");
return ox::Error(1, "reloadAsset is unsupported on this platform");
}
}
@@ -238,16 +236,16 @@ ox::Error setRomFs(Context &ctx, ox::UPtr<ox::FileSystem> &&fs) noexcept {
return buildUuidMap(ctx);
}
ox::Result<ox::UniquePtr<ox::FileSystem>> loadRomFs(ox::StringViewCR path) noexcept {
ox::Result<ox::UPtr<ox::FileSystem>> loadRomFs(ox::StringViewCR path) noexcept {
auto const lastDot = ox::lastIndexOf(path, '.');
if (!lastDot.error && substr(path, lastDot.value) == ".oxfs") {
oxRequire(rom, loadRom(path));
OX_REQUIRE(rom, loadRom(path));
return {ox::make_unique<ox::FileSystem32>(rom, 32 * ox::units::MB, unloadRom)};
} else {
#ifdef OX_HAS_PASSTHROUGHFS
return {ox::make_unique<ox::PassThroughFS>(path)};
#else
return OxError(2);
return ox::Error(2);
#endif
}
}

56
src/olympic/keel/src/pack-applib.cpp
View File

@@ -17,7 +17,7 @@ static ox::Error writeFileBuff(ox::StringView path, ox::BufferView const buff) n
std::ofstream f(std::string(toStdStringView(path)), std::ios::binary);
f.write(buff.data(), static_cast<intptr_t>(buff.size()));
} catch (std::fstream::failure const&) {
return OxError(2, "failed to write file");
return ox::Error(2, "failed to write file");
}
return {};
}
@@ -26,7 +26,7 @@ static ox::Result<ox::Buffer> readFileBuff(ox::StringView path) noexcept {
std::ifstream file(std::string(toStdStringView(path)), std::ios::binary | std::ios::ate);
if (!file.good()) {
oxErrorf("Could not find OxFS file: {}", path);
return OxError(1, "Could not find OxFS file");
return ox::Error(1, "Could not find OxFS file");
}
try {
auto const size = static_cast<std::size_t>(file.tellg());
@@ -36,14 +36,14 @@ static ox::Result<ox::Buffer> readFileBuff(ox::StringView path) noexcept {
return buff;
} catch (std::ios_base::failure const&e) {
oxErrorf("Could not read OxFS file: {}", e.what());
return OxError(2, "Could not read OxFS file");
return ox::Error(2, "Could not read OxFS file");
}
}
static ox::Error generateTypes(ox::TypeStore &ts) noexcept {
for (auto const mod : keel::modules()) {
for (auto gen : mod->types()) {
oxReturnError(gen(ts));
OX_RETURN_ERROR(gen(ts));
}
}
return {};
@@ -55,56 +55,48 @@ static ox::Error pack(
ox::StringView argManifest,
ox::StringView projectDataDir) noexcept {
ox::Buffer dstBuff(32 * ox::units::MB);
oxReturnError(ox::FileSystem32::format(dstBuff.data(), dstBuff.size()));
OX_RETURN_ERROR(ox::FileSystem32::format(dstBuff.data(), dstBuff.size()));
ox::FileSystem32 dst(dstBuff);
oxRequire(ctx, keel::init(ox::make_unique<ox::PassThroughFS>(argSrc), "keel-pack"));
OX_REQUIRE(ctx, keel::init(ox::make_unique<ox::PassThroughFS>(argSrc), "keel-pack"));
keel::TypeStore ts(*ctx->rom, ox::sfmt("{}/type_descriptors", projectDataDir));
oxReturnError(generateTypes(ts));
OX_RETURN_ERROR(generateTypes(ts));
keel::Manifest manifest;
oxReturnError(keel::pack(manifest, *ctx, ts, dst));
oxRequireM(pl, keel::GbaPreloader::make());
oxReturnError(preload(manifest, ts, dst, *pl));
oxReturnError(dst.resize());
OX_RETURN_ERROR(keel::pack(manifest, *ctx, ts, dst));
OX_REQUIRE_M(pl, keel::GbaPreloader::make());
OX_RETURN_ERROR(preload(manifest, ts, dst, *pl));
OX_RETURN_ERROR(dst.resize());
// resize buffer
oxRequire(dstSize, dst.size());
OX_REQUIRE(dstSize, dst.size());
dstBuff.resize(dstSize);
// concatenate ROM segments
oxRequireM(romBuff, readFileBuff(argRomBin));
OX_REQUIRE_M(romBuff, readFileBuff(argRomBin));
oxOutf("Input exe size: {} bytes\n", romBuff.size());
oxOutf("Dest FS size: {} bytes\n", dstSize);
oxOutf("Preload buff size: {} bytes\n", pl->buff().size());
oxReturnError(appendBinary(romBuff, dstBuff, *pl));
OX_RETURN_ERROR(appendBinary(romBuff, dstBuff, *pl));
oxOutf("Final ROM buff size: {} bytes\n", romBuff.size());
oxReturnError(writeFileBuff(argRomBin, romBuff));
oxRequire(manifestJson, ox::writeOCString(manifest));
oxReturnError(writeFileBuff(argManifest, {manifestJson.data(), manifestJson.len()}));
OX_RETURN_ERROR(writeFileBuff(argRomBin, romBuff));
OX_REQUIRE(manifestJson, ox::writeOCString(manifest));
OX_RETURN_ERROR(writeFileBuff(argManifest, {manifestJson.data(), manifestJson.len()}));
return {};
}
static ox::Error run(ox::SpanView<char const*> argv, ox::StringView projectDataDir) noexcept {
ox::Error run(
[[maybe_unused]] ox::StringView project,
[[maybe_unused]] ox::StringView appName,
ox::StringView projectDataDir,
ox::SpanView<ox::CString> argv) noexcept {
ox::ClArgs const args(argv);
auto const argSrc = args.getString("src", "");
auto const argRomBin = args.getString("rom-bin", "");
auto const argManifest = args.getString("manifest", "");
if (argSrc == "") {
oxErr("\033[31;1;1merror:\033[0m must specify a source directory\n");
return OxError(1, "must specify a source directory");
return ox::Error(1, "must specify a source directory");
}
if (argRomBin == "") {
oxErr("\033[31;1;1merror:\033[0m must specify a path for ROM file\n");
return OxError(1, "must specify a path for preload file");
return ox::Error(1, "must specify a path for preload file");
}
return pack(argSrc, argRomBin, argManifest, projectDataDir);
}
namespace olympic {
ox::Error run(
[[maybe_unused]] ox::StringView project,
[[maybe_unused]] ox::StringView appName,
ox::StringView projectDataDir,
ox::SpanView<char const*> argv) noexcept {
return ::run(argv, projectDataDir);
}
}

64
src/olympic/keel/src/pack.cpp
View File

@@ -15,19 +15,19 @@ static ox::Error pathToInode(
ox::FileSystem &dest,
ox::ModelObject &obj) noexcept {
auto &o = obj;
oxRequire(typeVal, o.at("type"));
OX_REQUIRE(typeVal, o.at("type"));
auto const type = static_cast<ox::FileAddressType>(typeVal->get<int8_t>());
oxRequire(dataVal, o.at("data"));
OX_REQUIRE(dataVal, o.at("data"));
auto &data = dataVal->get<ox::ModelUnion>();
ox::String path;
switch (type) {
case ox::FileAddressType::Path: {
oxRequire(pathVal, data.at("path"));
OX_REQUIRE(pathVal, data.at("path"));
path = pathVal->get<ox::String>();
break;
}
case ox::FileAddressType::ConstPath: {
oxRequire(pathVal, data.at("constPath"));
OX_REQUIRE(pathVal, data.at("constPath"));
path = pathVal->get<ox::String>();
break;
}
@@ -37,10 +37,10 @@ static ox::Error pathToInode(
}
if (beginsWith(path, "uuid://")) {
auto const uuid = ox::substr(path, 7);
oxReturnError(keel::uuidToPath(ctx, uuid).to<ox::String>().moveTo(path));
OX_RETURN_ERROR(keel::uuidToPath(ctx, uuid).to<ox::String>().moveTo(path));
}
oxRequire(s, dest.stat(path));
oxReturnError(typeVal->set(static_cast<int8_t>(ox::FileAddressType::Inode)));
OX_REQUIRE(s, dest.stat(path));
OX_RETURN_ERROR(typeVal->set(static_cast<int8_t>(ox::FileAddressType::Inode)));
oxOutf("\tpath to inode: {} => {}\n", path, s.inode);
return data.set(2, s.inode);
}
@@ -69,7 +69,7 @@ static ox::Error transformFileAddressesVec(
ox::FileSystem &dest,
ox::ModelValueVector &v) noexcept {
for (auto &f : v) {
oxReturnError(transformFileAddresses(ctx, dest, f));
OX_RETURN_ERROR(transformFileAddresses(ctx, dest, f));
}
return {};
}
@@ -87,7 +87,7 @@ static ox::Error transformFileAddressesObj(
}
for (auto &f : obj) {
auto &v = f->value;
oxReturnError(transformFileAddresses(ctx, dest, v));
OX_RETURN_ERROR(transformFileAddresses(ctx, dest, v));
}
return {};
}
@@ -96,12 +96,12 @@ static ox::Error performPackTransforms(
ManifestEntry &entry,
Context &ctx,
ox::Buffer &clawData) noexcept {
oxRequireM(typeId, readAssetTypeId(clawData));
OX_REQUIRE_M(typeId, readAssetTypeId(clawData));
for (auto const tr : packTransforms(ctx)) {
bool changed{};
oxReturnError(tr(ctx, clawData, typeId).moveTo(changed));
OX_RETURN_ERROR(tr(ctx, clawData, typeId).moveTo(changed));
if (changed) {
oxReturnError(readAssetTypeId(clawData).moveTo(typeId));
OX_RETURN_ERROR(readAssetTypeId(clawData).moveTo(typeId));
}
}
entry.type = ox::String{typeId};
@@ -115,17 +115,17 @@ static ox::Error doTransformations(
ox::FileSystem &dest,
ox::StringViewCR filePath) noexcept {
// load file
oxRequire(s, dest.stat(filePath));
OX_REQUIRE(s, dest.stat(filePath));
// do transformations
oxRequireM(buff, dest.read(s.inode));
oxReturnError(keel::performPackTransforms(manifest.files[filePath], ctx, buff));
OX_REQUIRE_M(buff, dest.read(s.inode));
OX_RETURN_ERROR(keel::performPackTransforms(manifest.files[filePath], ctx, buff));
// transform FileAddresses
oxRequireM(obj, keel::readAsset(ts, buff));
OX_REQUIRE_M(obj, keel::readAsset(ts, buff));
oxOutf("transforming {}\n", filePath);
oxReturnError(transformFileAddressesObj(ctx, dest, obj));
oxReturnError(ox::writeClaw(obj).moveTo(buff));
OX_RETURN_ERROR(transformFileAddressesObj(ctx, dest, obj));
OX_RETURN_ERROR(ox::writeClaw(obj).moveTo(buff));
// write file to dest
oxReturnError(dest.write(s.inode, buff));
OX_RETURN_ERROR(dest.write(s.inode, buff));
return {};
}
@@ -139,13 +139,13 @@ static ox::Error transformClaw(
ox::StringViewCR path) noexcept {
// copy
oxTracef("pack.transformClaw", "path: {}", path);
oxRequire(fileList, dest.ls(path));
OX_REQUIRE(fileList, dest.ls(path));
for (auto const&name : fileList) {
auto const filePath = ox::sfmt("{}{}", path, name);
oxRequire(stat, dest.stat(filePath));
OX_REQUIRE(stat, dest.stat(filePath));
if (stat.fileType == ox::FileType::Directory) {
auto const dir = ox::sfmt("{}{}/", path, name);
oxReturnError(transformClaw(manifest, ctx, ts, dest, dir));
OX_RETURN_ERROR(transformClaw(manifest, ctx, ts, dest, dir));
} else {
auto const err = doTransformations(manifest, ctx, ts, dest, filePath);
if (err) {
@@ -166,28 +166,28 @@ static ox::Error copy(
oxOutf("{}copying directory: {}\n", logPrefix, path);
auto const childLogPrefix = ox::sfmt("{}\t", logPrefix);
// copy
oxRequire(fileList, src.ls(path));
OX_REQUIRE(fileList, src.ls(path));
for (auto const&name : fileList) {
auto const currentFile = ox::sfmt("{}{}", path, name);
if (beginsWith(name, ".")) {
continue;
}
oxRequire(srcStat, src.stat(currentFile));
OX_REQUIRE(srcStat, src.stat(currentFile));
if (srcStat.fileType == ox::FileType::Directory) {
oxReturnError(dest.mkdir(currentFile, true));
oxReturnError(copy(manifest, src, dest, currentFile + '/', childLogPrefix));
OX_RETURN_ERROR(dest.mkdir(currentFile, true));
OX_RETURN_ERROR(copy(manifest, src, dest, currentFile + '/', childLogPrefix));
} else {
// load file
oxOutf("{}copying file: {}...", childLogPrefix, currentFile);
ox::StringView status = "failed";
oxDefer [&status] {
OX_DEFER [&status] {
oxOutf(" {}\n", status);
};
oxRequireM(buff, src.read(currentFile));
OX_REQUIRE_M(buff, src.read(currentFile));
// write file to dest
oxReturnError(dest.write(currentFile, buff));
OX_RETURN_ERROR(dest.write(currentFile, buff));
status = "OK";
oxRequire(dstStat, dest.stat(currentFile));
OX_REQUIRE(dstStat, dest.stat(currentFile));
manifest.files[currentFile] = {
.inode = dstStat.inode,
.type = ox::String{keel::readAssetTypeId(buff).or_value({})},
@@ -202,9 +202,9 @@ ox::Error pack(
keel::Context &ctx,
ox::TypeStore &ts,
ox::FileSystem &dest) noexcept {
oxReturnError(copy(manifest, *ctx.rom, dest, "/"));
OX_RETURN_ERROR(copy(manifest, *ctx.rom, dest, "/"));
oxOut("Doing transforms\n");
oxReturnError(transformClaw(manifest, ctx, ts, dest, "/"));
OX_RETURN_ERROR(transformClaw(manifest, ctx, ts, dest, "/"));
return {};
}

6
src/olympic/keel/src/typeconv.cpp
View File

@@ -18,7 +18,7 @@ static ox::Result<BaseConverter const*> findConverter(
return c;
}
}
return OxError(1, "Could not find converter");
return ox::Error(1, "Could not find converter");
};
static ox::Result<ox::UPtr<Wrap>> convert(
@@ -47,7 +47,7 @@ static ox::Result<ox::UPtr<Wrap>> convert(
return subConverter->convertPtrToPtr(ctx, *intermediate);
}
}
return OxError(1, "Could not convert between types");
return ox::Error(1, "Could not convert between types");
}
ox::Result<ox::UPtr<Wrap>> convert(
@@ -55,7 +55,7 @@ ox::Result<ox::UPtr<Wrap>> convert(
ox::BufferView const&srcBuffer,
ox::StringViewCR dstTypeName,
int dstTypeVersion) noexcept {
oxRequire(hdr, readAssetHeader(srcBuffer));
OX_REQUIRE(hdr, readAssetHeader(srcBuffer));
return convert(
ctx,
converters(ctx),

4
src/olympic/keel/src/typestore.cpp
View File

@@ -13,9 +13,9 @@ TypeStore::TypeStore(ox::FileSystem &fs, ox::StringView descPath) noexcept:
ox::Result<ox::UPtr<ox::DescriptorType>> TypeStore::loadDescriptor(ox::StringView const typeId) noexcept {
auto const path = ox::sfmt("{}/{}", m_descPath, typeId);
oxRequire(buff, m_fs.read(path));
OX_REQUIRE(buff, m_fs.read(path));
auto dt = ox::make_unique<ox::DescriptorType>();
oxReturnError(ox::readClaw<ox::DescriptorType>(buff, *dt));
OX_RETURN_ERROR(ox::readClaw<ox::DescriptorType>(buff, *dt));
return dt;
}

4
src/olympic/keel/test/tests.cpp
View File

@@ -15,10 +15,10 @@ static std::map<ox::StringView, ox::Error(*)()> tests = {
[]() -> ox::Error {
constexpr ox::StringView uuidStr = "8d814442-f46e-4cc3-8edc-ca3c01cc86db";
constexpr ox::StringView hdr = "K1;8d814442-f46e-4cc3-8edc-ca3c01cc86db;";
oxRequire(uuid, ox::UUID::fromString(uuidStr));
OX_REQUIRE(uuid, ox::UUID::fromString(uuidStr));
ox::Array<char, hdr.len()> buff;
ox::CharBuffWriter bw(buff);
oxReturnError(keel::writeUuidHeader(bw, uuid));
OX_RETURN_ERROR(keel::writeUuidHeader(bw, uuid));
oxExpect(ox::StringView(buff.data(), buff.size()), hdr);
return {};
}