[keel,nostalgia,turbine] Cleanup

[ox] Cleanup String/StringView conversions, MallocaPtr
2023-11-23 01:46:11 -06:00 · 2023-11-23 01:34:16 -06:00
47 changed files with 186 additions and 170 deletions
--- a/deps/ox/src/ox/clargs/clargs.cpp
+++ b/deps/ox/src/ox/clargs/clargs.cpp
@ -37,32 +37,32 @@ ClArgs::ClArgs(int argc, const char **args) noexcept {
 	}
 }

-bool ClArgs::getBool(ox::CRStringView arg, bool defaultValue) const noexcept {
+bool ClArgs::getBool(ox::CRString arg, bool defaultValue) const noexcept {
 	auto [value, err] = m_ints.at(arg);
 	return !err ? *value : defaultValue;
 }

-String ClArgs::getString(ox::CRStringView arg, const char *defaultValue) const noexcept {
+String ClArgs::getString(ox::CRString arg, const char *defaultValue) const noexcept {
 	auto [value, err] = m_strings.at(arg);
 	return !err ? *value : defaultValue;
 }

-int ClArgs::getInt(ox::CRStringView arg, int defaultValue) const noexcept {
+int ClArgs::getInt(ox::CRString arg, int defaultValue) const noexcept {
 	auto [value, err] = m_ints.at(arg);
 	return !err ? *value : defaultValue;
 }

-Result<bool> ClArgs::getBool(ox::CRStringView arg) const noexcept {
+Result<bool> ClArgs::getBool(ox::CRString arg) const noexcept {
 	oxRequire(out, m_bools.at(arg));
 	return *out;
 }

-Result<String> ClArgs::getString(ox::CRStringView argName) const noexcept {
+Result<String> ClArgs::getString(ox::CRString argName) const noexcept {
 	oxRequire(out, m_strings.at(argName));
 	return *out;
 }

-Result<int> ClArgs::getInt(ox::CRStringView arg) const noexcept {
+Result<int> ClArgs::getInt(ox::CRString arg) const noexcept {
 	oxRequire(out, m_ints.at(arg));
 	return *out;
 }
--- a/deps/ox/src/ox/clargs/clargs.hpp
+++ b/deps/ox/src/ox/clargs/clargs.hpp
@ -23,21 +23,21 @@ class ClArgs {
 		ClArgs(int argc, const char **args) noexcept;

 		[[nodiscard]]
-		bool getBool(ox::CRStringView arg, bool defaultValue) const noexcept;
+		bool getBool(ox::CRString arg, bool defaultValue) const noexcept;

 		[[nodiscard]]
-		String getString(ox::CRStringView argName, const char *defaultValue) const noexcept;
+		String getString(ox::CRString argName, const char *defaultValue) const noexcept;

 		[[nodiscard]]
-		int getInt(ox::CRStringView arg, int defaultValue) const noexcept;
+		int getInt(ox::CRString arg, int defaultValue) const noexcept;

 		[[nodiscard]]
-		Result<bool> getBool(ox::CRStringView arg) const noexcept;
+		Result<bool> getBool(ox::CRString arg) const noexcept;

 		[[nodiscard]]
-		Result<String> getString(ox::CRStringView argName) const noexcept;
+		Result<String> getString(ox::CRString argName) const noexcept;

-		Result<int> getInt(ox::CRStringView arg) const noexcept;
+		Result<int> getInt(ox::CRString arg) const noexcept;

 };

--- a/deps/ox/src/ox/event/signal.hpp
+++ b/deps/ox/src/ox/event/signal.hpp
@ -245,7 +245,7 @@ class Signal<Error(Args...)> {
 			}

 			Error call(Args... args) noexcept final {
-				return f(args...);
+				return f(ox::forward<Args>(args)...);
 			}
 		};

@ -260,7 +260,7 @@ class Signal<Error(Args...)> {
 			}

 			Error call(Args... args) noexcept final {
-				return (m_receiver->*(m_methodPtr))(args...);
+				return (m_receiver->*(m_methodPtr))(ox::forward<Args>(args)...);
 			}

 			void cleanup(Signal *signal) noexcept final {
@ -286,7 +286,7 @@ class Signal<Error(Args...)> {
 			}

 			Error call(Args... args) noexcept final {
-				return (m_receiver->*(m_methodPtr))(args...);
+				return (m_receiver->*(m_methodPtr))(ox::forward<Args>(args)...);
 			}

 			void cleanup(Signal*) noexcept final {
@ -391,14 +391,14 @@ Error Signal<Error(Args...)>::disconnectObject(const void *receiver) const noexc
 template<class... Args>
 void Signal<Error(Args...)>::emit(Args... args) const noexcept {
 	for (auto &f : m_slots) {
-		oxIgnoreError(f->call(args...));
+		oxIgnoreError(f->call(ox::forward<Args>(args)...));
 	}
 }

 template<class... Args>
 Error Signal<Error(Args...)>::emitCheckError(Args... args) const noexcept {
 	for (auto &f : m_slots) {
-		oxReturnError(f->call(args...));
+		oxReturnError(f->call(ox::forward<Args>(args)...));
 	}
 	return OxError(0);
 }
--- a/deps/ox/src/ox/fs/CMakeLists.txt
+++ b/deps/ox/src/ox/fs/CMakeLists.txt
@ -44,7 +44,6 @@ if(NOT OX_BARE_METAL)
 	target_link_libraries(
 		oxfs-tool
 			OxFS
-			OxStd
 	)

 	install(
--- a/deps/ox/src/ox/fs/filesystem/directory.hpp
+++ b/deps/ox/src/ox/fs/filesystem/directory.hpp
@ -252,7 +252,7 @@ Error Directory<FileStore, InodeId_t>::write(PathIterator path, uint64_t inode64

 		oxTracef("ox::fs::Directory::write", "Attempting to write Directory entry: {}", name->data());
 		oxReturnError(val->init(inode, name->data(), val.size()));
-		return m_fs.write(m_inodeId, cpy, cpy->size(), static_cast<uint8_t>(FileType::Directory));
+		return m_fs.write(m_inodeId, cpy.get(), cpy->size(), static_cast<uint8_t>(FileType::Directory));
 	}
 }

--- a/deps/ox/src/ox/fs/test/CMakeLists.txt
+++ b/deps/ox/src/ox/fs/test/CMakeLists.txt
@ -6,7 +6,6 @@ add_executable(
 target_link_libraries(
 	FSTests
 		OxFS
-		OxStd
 		OxMetalClaw
 )

--- a/deps/ox/src/ox/logconn/logconn.cpp
+++ b/deps/ox/src/ox/logconn/logconn.cpp
@ -58,7 +58,7 @@ ox::Error LoggerConn::initConn(ox::CRStringView appName) noexcept {
 	addr.sin_port = htons(5590);
 	m_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 	oxReturnError(OxError(static_cast<ox::ErrorCode>(connect(m_socket, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)))));
-	return sendInit({.appName = appName});
+	return sendInit({.appName = ox::BasicString<128>(appName)});
 }

 ox::Error LoggerConn::send(const char *buff, std::size_t len) const noexcept {
--- a/deps/ox/src/ox/mc/read.hpp
+++ b/deps/ox/src/ox/mc/read.hpp
@ -254,7 +254,7 @@ constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, HashMap<Stri
 				auto wkey = ox_malloca(keyLen + 1, char, 0);
 				auto wkeyPtr = wkey.get();
 				oxReturnError(handler.fieldCString("", &wkeyPtr, keyLen + 1));
-				return handler.field("", &val[wkey.get()]);
+				return handler.field("", &val[wkeyPtr]);
 			};
 			for (std::size_t i = 0; i < len; ++i) {
 				oxReturnError(loopBody(handler, *val));
--- a/deps/ox/src/ox/mc/write.hpp
+++ b/deps/ox/src/ox/mc/write.hpp
@ -363,7 +363,7 @@ constexpr Error MetalClawWriter<Writer>::field(const char*, const HashMap<String
 		constexpr auto loopBody = [](auto &handler, auto const&key, auto const&val) -> ox::Error {
 			const auto keyLen = ox_strlen(key);
 			auto wkey = ox_malloca(keyLen + 1, char, 0);
-			memcpy(wkey, key.c_str(), keyLen + 1);
+			memcpy(wkey.get(), key.c_str(), keyLen + 1);
 			oxReturnError(handler.fieldCString("", wkey.get(), keyLen));
 			oxRequireM(value, val.at(key));
 			return handler.field("", value);
--- a/deps/ox/src/ox/model/descwrite.hpp
+++ b/deps/ox/src/ox/model/descwrite.hpp
@ -175,7 +175,8 @@ class TypeDescWriter {
 constexpr TypeDescWriter::TypeDescWriter(TypeStore *typeStore) noexcept: m_typeStore(typeStore) {}

 template<typename T>
-constexpr ox::Error TypeDescWriter::setTypeInfo(CRStringView typeName, int typeVersion,
+constexpr ox::Error TypeDescWriter::setTypeInfo(
+		CRStringView typeName, int typeVersion,
      const TypeParamPack &typeParams, std::size_t) noexcept {
 	PrimitiveType pt;
 	if constexpr(is_union_v<T>) {
@ -197,7 +198,7 @@ constexpr Error TypeDescWriter::field(CRStringView name, const T*, std::size_t,
 		constexpr typename remove_pointer<T>::type *p = nullptr;
 		const auto t = type(p);
 		oxAssert(t != nullptr, "field(const char *name, T *val, std::size_t): Type not found or generated");
-		m_type->fieldList.emplace_back(t, name, detail::indirectionLevels_v<T> + 1, subscriptStack, buildTypeId(*t));
+		m_type->fieldList.emplace_back(t, String(name), detail::indirectionLevels_v<T> + 1, subscriptStack, buildTypeId(*t));
 		return OxError(0);
 	}
 	return OxError(1);
@ -208,7 +209,7 @@ constexpr Error TypeDescWriter::field(CRStringView name, UnionView<T, force> val
 	if (m_type) {
 		const auto t = type(val);
 		oxAssert(t != nullptr, "field(const char *name, T val): Type not found or generated");
-		m_type->fieldList.emplace_back(t, name, 0, SubscriptStack{}, t->typeName);
+		m_type->fieldList.emplace_back(t, String(name), 0, SubscriptStack{}, t->typeName);
 		return OxError(0);
 	}
 	return OxError(1);
@ -226,7 +227,7 @@ constexpr Error TypeDescWriter::field(CRStringView name, const T *val) noexcept
 		} else {
 			const auto t = type(val);
 			oxAssert(t != nullptr, "field(const char *name, T *val): Type not found or generated");
-			m_type->fieldList.emplace_back(t, name, 0, SubscriptStack{}, buildTypeId(*t));
+			m_type->fieldList.emplace_back(t, String(name), 0, SubscriptStack{}, buildTypeId(*t));
 			return {};
 		}
 	}
@ -237,7 +238,7 @@ template<typename ...Args>
 constexpr Error TypeDescWriter::fieldCString(CRStringView name, Args&&...) noexcept {
 	constexpr auto s = "";
 	const auto t = type(s);
-	m_type->fieldList.emplace_back(t, name, 0, SubscriptStack{}, t->typeName);
+	m_type->fieldList.emplace_back(t, String(name), 0, SubscriptStack{}, t->typeName);
 	return {};
 }

@ -344,7 +345,7 @@ constexpr const DescriptorType *TypeDescWriter::getType(CRStringView tn, int typ
 		oxAssert(type != nullptr, "TypeDescWriter::getType returning null DescriptorType");
 		return type;
 	} else {
-		auto dt = ox::make_unique<DescriptorType>(tn, typeVersion, pt, typeParams);
+		auto dt = ox::make_unique<DescriptorType>(String(tn), typeVersion, pt, typeParams);
 		dt->length = b;
 		const auto out = dt.get();
 		const auto typeId = buildTypeId(tn, typeVersion, typeParams);
--- a/deps/ox/src/ox/model/typestore.hpp
+++ b/deps/ox/src/ox/model/typestore.hpp
@ -44,11 +44,11 @@ class TypeStore {
 			return out->get();
 		}

-		constexpr DescriptorType *getInit(const auto &typeName, int typeVersion, PrimitiveType pt,
+		constexpr DescriptorType *getInit(CRStringView typeName, int typeVersion, PrimitiveType pt,
 		                                  const TypeParamPack &typeParams) noexcept {
 			const auto typeId = buildTypeId(typeName, typeVersion, typeParams);
 			auto &out = m_cache[typeId];
-			out = ox::make_unique<DescriptorType>(typeName, typeVersion, pt, typeParams);
+			out = ox::make_unique<DescriptorType>(String(typeName), typeVersion, pt, typeParams);
 			return out.get();
 		}

--- a/deps/ox/src/ox/std/error.hpp
+++ b/deps/ox/src/ox/std/error.hpp
@ -25,8 +25,6 @@ class exception {
 #endif

 #include "def.hpp"
-#include "defines.hpp"
-#include "strongint.hpp"
 #include "typetraits.hpp"
 #include "utility.hpp"

@ -191,6 +189,13 @@ struct [[nodiscard]] Result {
 		return value;
 	}

+	constexpr auto &unwrapThrow() {
+		if (error) {
+			throw ox::Exception(error);
+		}
+		return value;
+	}
+
 	constexpr const auto &unwrap() const noexcept {
 		if (error) [[unlikely]] {
 			oxPanic(error, "Failed unwrap");
@ -198,7 +203,8 @@ struct [[nodiscard]] Result {
 		return value;
 	}

-	constexpr ox::Result<T> to(const auto &f) noexcept {
+	template<typename U = T>
+	constexpr ox::Result<U> to(const auto &f) noexcept {
 		if (error) [[unlikely]] {
 			return OxError(1);
 		}
--- a/deps/ox/src/ox/std/new.hpp
+++ b/deps/ox/src/ox/std/new.hpp
@ -115,11 +115,11 @@ class MallocaPtr {
 			return reinterpret_cast<T*>(m_val);
 		}

-		constexpr const T &operator=(MallocaPtr &other) = delete;
+		constexpr MallocaPtr &operator=(MallocaPtr &other) = delete;

-		constexpr const T &operator=(const MallocaPtr &other) = delete;
+		constexpr MallocaPtr &operator=(const MallocaPtr &other) = delete;

-		constexpr const T &operator=(MallocaPtr &&other) noexcept {
+		constexpr MallocaPtr &operator=(MallocaPtr &&other) noexcept {
 			if (m_onHeap && m_val) {
 				delete[] reinterpret_cast<uint8_t*>(m_val);
 			}
@ -127,6 +127,7 @@ class MallocaPtr {
 			m_val = other.m_val;
 			other.m_onHeap = false;
 			other.m_val = nullptr;
+			return *this;
 		}

 		constexpr const T *operator->() const noexcept {
@ -137,11 +138,11 @@ class MallocaPtr {
 			return reinterpret_cast<T*>(m_val);
 		}

-		constexpr operator const T*() const noexcept {
+		constexpr explicit operator const T*() const noexcept {
 			return reinterpret_cast<T*>(m_val);
 		}

-		constexpr operator T*() noexcept {
+		constexpr explicit operator T*() noexcept {
 			return reinterpret_cast<T*>(m_val);
 		}

@ -153,6 +154,10 @@ class MallocaPtr {
 			return *reinterpret_cast<T*>(m_val);
 		}

+		constexpr bool operator==(std::nullptr_t) const noexcept {
+			return m_val == nullptr;
+		}
+
 		constexpr bool operator==(const MallocaPtr<T> &other) const noexcept {
 			return m_val == other.m_val && m_onHeap == other.m_onHeap;
 		}
--- a/deps/ox/src/ox/std/span.hpp
+++ b/deps/ox/src/ox/std/span.hpp
@ -10,8 +10,6 @@

 #include "bit.hpp"
 #include "iterator.hpp"
-#include "typetraits.hpp"
-#include "types.hpp"
 #include "vector.hpp"

 namespace ox {
--- a/deps/ox/src/ox/std/string.hpp
+++ b/deps/ox/src/ox/std/string.hpp
@ -13,12 +13,10 @@
 #endif

 #include "algorithm.hpp"
-#include "buffer.hpp"
 #include "memops.hpp"
 #include "serialize.hpp"
 #include "stringview.hpp"
 #include "strops.hpp"
-#include "typetraits.hpp"
 #include "vector.hpp"

 namespace ox {
@ -40,7 +38,7 @@ class BasicString {

 		constexpr BasicString(const char *str, std::size_t size) noexcept;

-		constexpr BasicString(CRStringView str) noexcept;
+		constexpr explicit BasicString(CRStringView str) noexcept;

 		constexpr BasicString(const BasicString&) noexcept;

@ -140,6 +138,8 @@ class BasicString {

 		constexpr BasicString operator+(Integer_c auto i) const noexcept;

+		constexpr BasicString operator+(CRStringView src) const noexcept;
+
 		constexpr BasicString operator+(const BasicString &src) const noexcept;

 		constexpr bool operator==(const char *other) const noexcept;
@ -414,6 +414,17 @@ constexpr BasicString<SmallStringSize_v> BasicString<SmallStringSize_v>::operato
 	return *this + str;
 }

+template<std::size_t SmallStringSize_v>
+constexpr BasicString<SmallStringSize_v> BasicString<SmallStringSize_v>::operator+(CRStringView src) const noexcept {
+	const std::size_t strLen = src.len();
+	const auto currentLen = len();
+	BasicString<SmallStringSize_v> cpy(currentLen + strLen);
+	cpy.m_buff.resize(m_buff.size() + strLen);
+	memcpy(&cpy.m_buff[0], m_buff.data(), currentLen);
+	memcpy(&cpy.m_buff[currentLen], src.data(), strLen + 1);
+	return cpy;
+}
+
 template<std::size_t SmallStringSize_v>
 constexpr BasicString<SmallStringSize_v> BasicString<SmallStringSize_v>::operator+(const BasicString &src) const noexcept {
 	const std::size_t strLen = src.len();
--- a/deps/ox/src/ox/std/trace.hpp
+++ b/deps/ox/src/ox/std/trace.hpp
@ -131,7 +131,7 @@ class OutStream {
 			m_msg.file = file;
 			m_msg.line = line;
 			m_msg.ch = ch;
-			m_msg.msg = msg;
+			m_msg.msg = BasicString<100>(msg);
 		}

 		constexpr OutStream(const char *file, int line, const char *ch, const char *msg = "") noexcept {
--- a/deps/ox/src/ox/std/uuid.hpp
+++ b/deps/ox/src/ox/std/uuid.hpp
@ -10,11 +10,10 @@

 #include "array.hpp"
 #include "bstring.hpp"
+#include "buffer.hpp"
 #include "random.hpp"
 #include "ranges.hpp"
 #include "stringview.hpp"
-#include "strops.hpp"
-#include "trace.hpp"

 namespace ox {

--- a/src/keel/CMakeLists.txt
+++ b/src/keel/CMakeLists.txt
@ -17,7 +17,6 @@ target_link_libraries(
 		OxFS
 		OxModel
 		OxPreloader
-		OxStd
 )

 install(
--- a/src/keel/media.hpp
+++ b/src/keel/media.hpp
@ -56,20 +56,24 @@ ox::Result<keel::AssetRef<T>> readObjFile(
 		path = ctx->uuidToPath[assetId];
 	} else {
 		path = assetId;
-		uuidStr = ctx->pathToUuid[path].toString();
+		// Warning: StringView to String
+		uuidStr = ctx->pathToUuid[ox::String(path)].toString();
 		assetId = uuidStr;
 	}
 	if (forceLoad) {
 		oxRequire(buff, ctx->rom->read(path));
 		oxRequire(obj, readConvert(ctx, buff));
-		oxRequire(cached, ctx->assetManager.setAsset(assetId, obj));
+		// Warning: StringView to String
+		oxRequire(cached, ctx->assetManager.setAsset(ox::String(assetId), obj));
 		return cached;
 	} else {
-		auto [cached, err] = ctx->assetManager.getAsset<T>(assetId);
+		// Warning: StringView to String
+		auto [cached, err] = ctx->assetManager.getAsset<T>(ox::String(assetId));
 		if (err) {
 			oxRequire(buff, ctx->rom->read(path));
 			oxRequire(obj, readConvert(ctx, buff));
-			oxReturnError(ctx->assetManager.setAsset(assetId, obj).moveTo(&cached));
+			// Warning: StringView to String
+			oxReturnError(ctx->assetManager.setAsset(ox::String(assetId), obj).moveTo(&cached));
 		}
 		return cached;
 	}
@ -103,12 +107,14 @@ ox::Result<AssetRef<T>> setAsset(keel::Context *ctx, ox::StringView assetId, T c
 	}
 	ox::UUIDStr idStr;
 	if (assetId[0] == '/') {
-		const auto [id, err] = ctx->pathToUuid.at(assetId);
+		// Warning: StringView to String
+		const auto [id, err] = ctx->pathToUuid.at(ox::String(assetId));
 		oxReturnError(err);
 		idStr = id->toString();
 		assetId = idStr;
 	}
-	return ctx->assetManager.setAsset(assetId, asset);
+	// Warning: StringView to String
+	return ctx->assetManager.setAsset(ox::String(assetId), asset);
 #else
 	return OxError(1, "Not supported on this platform");
 #endif
--- a/src/nostalgia/modules/core/src/studio/paletteeditor-imgui.cpp
+++ b/src/nostalgia/modules/core/src/studio/paletteeditor-imgui.cpp
@ -15,20 +15,11 @@

 namespace nostalgia::core {

-ox::Result<PaletteEditorImGui*> PaletteEditorImGui::make(turbine::Context *ctx, ox::CRStringView path) noexcept {
-	ox::UniquePtr<PaletteEditorImGui> out;
-	try {
-		out = ox::UniquePtr<PaletteEditorImGui>(new PaletteEditorImGui);
-	} catch (...) {
-		return OxError(1);
-	}
-	out->m_ctx = ctx;
-	out->m_itemPath = path;
-	const auto lastSlash = std::find(out->m_itemPath.rbegin(), out->m_itemPath.rend(), '/').offset();
-	out->m_itemName = out->m_itemPath.substr(lastSlash + 1);
-	oxRequire(pal, keel::readObj<Palette>(&out->m_ctx->keelCtx, ox::FileAddress(out->m_itemPath.c_str())));
-	out->m_pal = *pal;
-	return out.release();
+PaletteEditorImGui::PaletteEditorImGui(turbine::Context *ctx, ox::String path):
+	m_ctx(ctx),
+	m_itemPath(std::move(path)),
+	m_itemName(m_itemPath.substr(std::find(m_itemPath.rbegin(), m_itemPath.rend(), '/').offset() + 1)),
+	m_pal(*keel::readObj<Palette>(&m_ctx->keelCtx, ox::FileAddress(m_itemPath.c_str())).unwrapThrow()) {
 }

 const ox::String &PaletteEditorImGui::itemName() const noexcept {
@ -93,21 +84,25 @@ void PaletteEditorImGui::draw(turbine::Context*) noexcept {
 			ImGui::TableSetupColumn("Blue", ImGuiTableColumnFlags_WidthFixed, 50);
 			ImGui::TableSetupColumn("Color Preview", ImGuiTableColumnFlags_NoHide);
 			ImGui::TableHeadersRow();
+			constexpr auto colVal = [] (unsigned num) {
+				ox::Array<char, 4> numStr;
+				ImGui::TableNextColumn();
+				ox_itoa(num, numStr.data());
+				ImGui::SetCursorPosX(
+						ImGui::GetCursorPosX() + ImGui::GetColumnWidth() - ImGui::CalcTextSize(numStr.data()).x);
+				ImGui::Text("%s", numStr.data());
+			};
 			for (auto i = 0u; const auto c : m_pal.colors) {
 				ImGui::PushID(static_cast<int>(i));
 				ImGui::TableNextRow();
 				// Color No.
-				ImGui::TableNextColumn();
-				ImGui::Text("%d", i);
+				colVal(i);
 				// Red
-				ImGui::TableNextColumn();
-				ImGui::Text("%d", red16(c));
+				colVal(red16(c));
 				// Green
-				ImGui::TableNextColumn();
-				ImGui::Text("%d", green16(c));
+				colVal(green16(c));
 				// Blue
-				ImGui::TableNextColumn();
-				ImGui::Text("%d", blue16(c));
+				colVal(blue16(c));
 				// ColorPreview
 				ImGui::TableNextColumn();
 				const auto ic = ImGui::GetColorU32(ImVec4(redf(c), greenf(c), bluef(c), 1));
--- a/src/nostalgia/modules/core/src/studio/paletteeditor-imgui.hpp
+++ b/src/nostalgia/modules/core/src/studio/paletteeditor-imgui.hpp
@ -15,15 +15,15 @@ class PaletteEditorImGui: public studio::Editor {

 	private:
 		turbine::Context *m_ctx = nullptr;
-		ox::String m_itemName;
 		ox::String m_itemPath;
+		ox::String m_itemName;
 		Palette m_pal;
 		std::size_t m_selectedRow = 0;

 		PaletteEditorImGui() noexcept = default;

 	public:
-		static ox::Result<PaletteEditorImGui*> make(turbine::Context *ctx, ox::CRStringView path) noexcept;
+		PaletteEditorImGui(turbine::Context *ctx, ox::String path);

 		/**
 		 * Returns the name of item being edited.
--- a/src/nostalgia/modules/core/src/studio/studiomodule.cpp
+++ b/src/nostalgia/modules/core/src/studio/studiomodule.cpp
@ -17,13 +17,13 @@ class StudioModule: public studio::Module {
 			{
 				{FileExt_ng},
 				[ctx](ox::CRStringView path) -> ox::Result<studio::BaseEditor*> {
-					return ox::makeCatch<TileSheetEditorImGui>(ctx, path);
+					return ox::makeCatch<TileSheetEditorImGui>(ctx, ox::String(path));
 				}
 			},
 			{
 				{FileExt_npal},
 				[ctx](ox::CRStringView path) -> ox::Result<studio::BaseEditor*> {
-					return PaletteEditorImGui::make(ctx, path);
+					return ox::makeCatch<PaletteEditorImGui>(ctx, ox::String(path));
 				}
 			}
 		};
--- a/src/nostalgia/modules/core/src/studio/tilesheeteditor-imgui.cpp
+++ b/src/nostalgia/modules/core/src/studio/tilesheeteditor-imgui.cpp
@ -38,9 +38,9 @@ ox::Error toPngFile(const ox::String &path, const TileSheet::SubSheet &s, const
 	return OxError(static_cast<ox::ErrorCode>(lodepng_encode_file(path.c_str(), outData.data(), width, height, fmt, 8)));
 }

-TileSheetEditorImGui::TileSheetEditorImGui(turbine::Context *ctx, ox::CRStringView path): m_tileSheetEditor(ctx, path) {
+TileSheetEditorImGui::TileSheetEditorImGui(turbine::Context *ctx, ox::String path): m_tileSheetEditor(ctx, path) {
 	m_ctx = ctx;
-	m_itemPath = path;
+	m_itemPath = std::move(path);
 	const auto lastSlash = ox::find(m_itemPath.rbegin(), m_itemPath.rend(), '/').offset();
 	m_itemName = m_itemPath.substr(lastSlash + 1);
 	// init palette idx
@ -393,7 +393,7 @@ void TileSheetEditorImGui::drawPaletteSelector() noexcept {
 	}
 }

-ox::Error TileSheetEditorImGui::updateActiveSubsheet(const ox::String &name, int cols, int rows) noexcept {
+ox::Error TileSheetEditorImGui::updateActiveSubsheet(const ox::StringView &name, int cols, int rows) noexcept {
 	return model()->updateSubsheet(model()->activeSubSheetIdx(), name, cols, rows);
 }

--- a/src/nostalgia/modules/core/src/studio/tilesheeteditor-imgui.hpp
+++ b/src/nostalgia/modules/core/src/studio/tilesheeteditor-imgui.hpp
@ -55,7 +55,7 @@ class TileSheetEditorImGui: public studio::BaseEditor {
 		Tool m_tool = Tool::Draw;

 	public:
-		TileSheetEditorImGui(turbine::Context *ctx, ox::CRStringView path);
+		TileSheetEditorImGui(turbine::Context *ctx, ox::String path);

 		~TileSheetEditorImGui() override = default;

@ -116,7 +116,7 @@ class TileSheetEditorImGui: public studio::BaseEditor {

 		void drawPaletteSelector() noexcept;

-		ox::Error updateActiveSubsheet(const ox::String &name, int cols, int rows) noexcept;
+		ox::Error updateActiveSubsheet(const ox::StringView &name, int cols, int rows) noexcept;

 	// slots
 	private:
--- a/src/nostalgia/modules/core/src/studio/tilesheeteditormodel.cpp
+++ b/src/nostalgia/modules/core/src/studio/tilesheeteditormodel.cpp
@ -488,13 +488,13 @@ class UpdateSubSheetCommand: public TileSheetCommand {
 		UpdateSubSheetCommand(
 				TileSheet &img,
 				TileSheet::SubSheetIdx idx,
-		        const ox::String &name,
+				ox::String name,
 				int cols,
 				int rows) noexcept:
 				m_img(img),
 				m_idx(std::move(idx)) {
 			m_sheet = m_img.getSubSheet(m_idx);
-			m_newName = name;
+			m_newName = std::move(name);
 			m_newCols = cols;
 			m_newRows = rows;
 		}
@ -682,8 +682,8 @@ void TileSheetEditorModel::deleteTiles(const TileSheet::SubSheetIdx &idx, std::s
 	pushCommand(ox::make<DeleteTilesCommand>(m_img, idx, tileIdx, tileCnt));
 }

-ox::Error TileSheetEditorModel::updateSubsheet(const TileSheet::SubSheetIdx &idx, const ox::String &name, int cols, int rows) noexcept {
-	pushCommand(ox::make<UpdateSubSheetCommand>(m_img, idx, name, cols, rows));
+ox::Error TileSheetEditorModel::updateSubsheet(const TileSheet::SubSheetIdx &idx, const ox::StringView &name, int cols, int rows) noexcept {
+	pushCommand(ox::make<UpdateSubSheetCommand>(m_img, idx, ox::String(name), cols, rows));
 	return {};
 }

--- a/src/nostalgia/modules/core/src/studio/tilesheeteditormodel.hpp
+++ b/src/nostalgia/modules/core/src/studio/tilesheeteditormodel.hpp
@ -72,7 +72,7 @@ class TileSheetEditorModel: public ox::SignalHandler {

 		void deleteTiles(const TileSheet::SubSheetIdx &idx, std::size_t tileIdx, std::size_t tileCnt) noexcept;

-		ox::Error updateSubsheet(const TileSheet::SubSheetIdx &idx, const ox::String &name, int cols, int rows) noexcept;
+		ox::Error updateSubsheet(const TileSheet::SubSheetIdx &idx, const ox::StringView &name, int cols, int rows) noexcept;

 		void setActiveSubsheet(const TileSheet::SubSheetIdx&) noexcept;

--- a/src/nostalgia/modules/core/src/studio/tilesheeteditorview.cpp
+++ b/src/nostalgia/modules/core/src/studio/tilesheeteditorview.cpp
@ -11,8 +11,8 @@

 namespace nostalgia::core {

-TileSheetEditorView::TileSheetEditorView(turbine::Context *ctx, ox::CRStringView path):
-	m_model(ctx, path), m_pixelsDrawer(&m_model) {
+TileSheetEditorView::TileSheetEditorView(turbine::Context *ctx, ox::String path):
+	m_model(ctx, std::move(path)), m_pixelsDrawer(&m_model) {
 	// build shaders
 	oxThrowError(m_pixelsDrawer.buildShader());
 	oxThrowError(m_pixelGridDrawer.buildShader());
--- a/src/nostalgia/modules/core/src/studio/tilesheeteditorview.hpp
+++ b/src/nostalgia/modules/core/src/studio/tilesheeteditorview.hpp
@ -50,7 +50,7 @@ class TileSheetEditorView: public ox::SignalHandler {
 		std::size_t m_palIdx = 0;

 	public:
-		TileSheetEditorView(turbine::Context *ctx, ox::CRStringView path);
+		TileSheetEditorView(turbine::Context *ctx, ox::String path);

 		~TileSheetEditorView() override = default;

--- a/src/nostalgia/modules/scene/include/nostalgia/scene/scene.hpp
+++ b/src/nostalgia/modules/scene/include/nostalgia/scene/scene.hpp
@ -15,7 +15,7 @@ class Scene {
 	public:
 		explicit Scene(const SceneStatic &sceneStatic) noexcept;

-		ox::Error setupDisplay(core::Context *ctx) const noexcept;
+		ox::Error setupDisplay(core::Context &ctx) const noexcept;

 	private:
 		void setupLayer(core::Context*, const ox::Vector<uint16_t> &layer, unsigned layerNo) const noexcept;
--- a/src/nostalgia/modules/scene/src/scene.cpp
+++ b/src/nostalgia/modules/scene/src/scene.cpp
@ -12,17 +12,17 @@ Scene::Scene(const SceneStatic &sceneStatic) noexcept:
 	m_sceneStatic(sceneStatic) {
 }

-ox::Error Scene::setupDisplay(core::Context *ctx) const noexcept {
+ox::Error Scene::setupDisplay(core::Context &ctx) const noexcept {
 	if (m_sceneStatic.palettes.empty()) {
 		return OxError(1, "Scene has no palettes");
 	}
 	const auto &palette = m_sceneStatic.palettes[0];
 	oxReturnError(core::loadBgTileSheet(
-				ctx, 0, m_sceneStatic.tilesheet, palette));
+				&ctx, 0, m_sceneStatic.tilesheet, palette));
 	// disable all backgrounds
-	core::setBgStatus(ctx, 0);
+	core::setBgStatus(&ctx, 0);
 	for (auto layerNo = 0u; const auto &layer : m_sceneStatic.tileMapIdx) {
-		setupLayer(ctx, layer, layerNo);
+		setupLayer(&ctx, layer, layerNo);
 		++layerNo;
 	}
 	return {};
--- a/src/nostalgia/modules/scene/src/studio/sceneeditor-imgui.cpp
+++ b/src/nostalgia/modules/scene/src/studio/sceneeditor-imgui.cpp
@ -10,11 +10,11 @@

 namespace nostalgia::scene {

-SceneEditorImGui::SceneEditorImGui(turbine::Context *ctx, ox::CRStringView path):
-	m_editor(ctx, path),
-	m_view(ctx, m_editor.scene()) {
-	m_ctx = ctx;
-	m_itemPath = path;
+SceneEditorImGui::SceneEditorImGui(turbine::Context &ctx, ox::String path):
+	m_ctx(ctx),
+	m_itemPath(std::move(path)),
+	m_editor(&m_ctx, m_itemPath),
+	m_view(&m_ctx, m_editor.scene()) {
 	const auto lastSlash = std::find(m_itemPath.rbegin(), m_itemPath.rend(), '/').offset();
 	m_itemName = m_itemPath.substr(lastSlash + 1);
 	setRequiresConstantRefresh(false);
@ -48,9 +48,9 @@ void SceneEditorImGui::onActivated() noexcept {
 }

 ox::Error SceneEditorImGui::saveItem() noexcept {
-	const auto sctx = applicationData<studio::StudioContext>(*m_ctx);
+	const auto sctx = applicationData<studio::StudioContext>(m_ctx);
 	oxReturnError(sctx->project->writeObj(m_itemPath, &m_editor.scene()));
-	oxReturnError(m_ctx->keelCtx.assetManager.setAsset(m_itemPath, m_editor.scene()));
+	oxReturnError(m_ctx.keelCtx.assetManager.setAsset(m_itemPath, m_editor.scene()));
 	return {};
 }

--- a/src/nostalgia/modules/scene/src/studio/sceneeditor-imgui.hpp
+++ b/src/nostalgia/modules/scene/src/studio/sceneeditor-imgui.hpp
@ -16,14 +16,14 @@ namespace nostalgia::scene {
 class SceneEditorImGui: public studio::Editor {

 	private:
-		turbine::Context *m_ctx = nullptr;
+		turbine::Context &m_ctx;
 		ox::String m_itemName;
 		ox::String m_itemPath;
 		SceneEditor m_editor;
 		SceneEditorView m_view;

 	public:
-		SceneEditorImGui(turbine::Context *ctx, ox::CRStringView path);
+		SceneEditorImGui(turbine::Context &ctx, ox::String path);

 		/**
 		 * Returns the name of item being edited.
--- a/src/nostalgia/modules/scene/src/studio/sceneeditorview.cpp
+++ b/src/nostalgia/modules/scene/src/studio/sceneeditorview.cpp
@ -15,7 +15,7 @@ SceneEditorView::SceneEditorView(turbine::Context *tctx, const SceneStatic &scen
 }

 ox::Error SceneEditorView::setupScene() noexcept {
-	return m_scene.setupDisplay(m_cctx.get());
+	return m_scene.setupDisplay(*m_cctx);
 }

 void SceneEditorView::draw(int width, int height) noexcept {
--- a/src/nostalgia/modules/scene/src/studio/studiomodule.cpp
+++ b/src/nostalgia/modules/scene/src/studio/studiomodule.cpp
@ -19,7 +19,7 @@ ox::Vector<studio::EditorMaker> StudioModule::editors(turbine::Context *ctx) con
 		{
 			{"nscn"},
 			[ctx](ox::CRStringView path) -> ox::Result<studio::BaseEditor*> {
-				return ox::makeCatch<SceneEditorImGui>(ctx, path);
+				return ox::makeCatch<SceneEditorImGui>(*ctx, ox::String(path));
 			}
 		},
 	};
--- a/src/nostalgia/player/app.cpp
+++ b/src/nostalgia/player/app.cpp
@ -33,7 +33,6 @@ static void keyEventHandler(turbine::Context &tctx, turbine::Key key, bool down)
 }

 ox::Error run(ox::UniquePtr<ox::FileSystem> &&fs) noexcept {
-	oxTraceInitHook();
 	oxRequireM(tctx, turbine::init(std::move(fs), "Nostalgia"));
 	oxRequireM(cctx, core::init(tctx.get()));
 	constexpr ox::FileAddress SceneAddr("/Scenes/Chester.nscn");
@ -41,6 +40,6 @@ ox::Error run(ox::UniquePtr<ox::FileSystem> &&fs) noexcept {
 	turbine::setUpdateHandler(*tctx, updateHandler);
 	turbine::setKeyEventHandler(*tctx, keyEventHandler);
 	s_scene.emplace(*scn);
-	oxReturnError(s_scene->setupDisplay(cctx.get()));
+	oxReturnError(s_scene->setupDisplay(*cctx));
 	return turbine::run(*tctx);
 }
--- a/src/nostalgia/player/main.cpp
+++ b/src/nostalgia/player/main.cpp
@ -2,6 +2,7 @@
 * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
 */

+#include <ox/logconn/def.hpp>
 #include <ox/logconn/logconn.hpp>

 #include <keel/media.hpp>
@ -11,8 +12,7 @@
 #include "app.hpp"

 static ox::Error run(int argc, const char **argv) noexcept {
-	ox::trace::init();
-#ifdef OX_USE_STDLIB
+#ifndef OX_BARE_METAL
 	// GBA doesn't need the modules and calling this doubles the size of the
 	// binary.
 	nostalgia::registerKeelModules();
@ -33,16 +33,19 @@ int WinMain() {
 #else
 int main(int argc, const char **argv) {
 #endif
-#if defined(DEBUG) && !defined(OX_BARE_METAL)
-	ox::LoggerConn loggerConn;
-	const auto loggerErr = loggerConn.initConn("Nostalgia Player");
-	if (loggerErr) {
-		oxErrf("Could not connect to logger: {} ({}:{})\n", toStr(loggerErr), loggerErr.file, loggerErr.line);
-	} else {
-		ox::trace::setLogger(&loggerConn);
+	OX_INIT_DEBUG_LOGGER(loggerConn, "Nostalgia Player")
+	ox::Error err;
+#ifdef __cpp_exceptions
+	try {
+		err = run(argc, argv);
+	} catch (ox::Exception const&ex) {
+		err = ex.toError();
+	} catch (...) {
+		err = OxError(1, "Non-Ox exception");
 	}
+#else
+	err = run(argc, argv);
 #endif
-	const auto err = run(argc, argv);
 	oxAssert(err, "Something went wrong...");
 	return static_cast<int>(err);
 }
--- a/src/nostalgia/tools/CMakeLists.txt
+++ b/src/nostalgia/tools/CMakeLists.txt
@ -4,7 +4,6 @@ target_link_libraries(
 	nost-pack
 		OxClArgs
 		OxLogConn
-		Keel
 		NostalgiaKeelModules
 )

--- a/src/nostalgia/tools/pack.cpp
+++ b/src/nostalgia/tools/pack.cpp
@ -6,6 +6,7 @@

 #include <ox/clargs/clargs.hpp>
 #include <ox/fs/fs.hpp>
+#include <ox/logconn/def.hpp>
 #include <ox/logconn/logconn.hpp>

 #include <keel/keel.hpp>
@ -50,7 +51,6 @@ static ox::Error generateTypes(ox::TypeStore *ts) noexcept {
 }

 static ox::Error run(const ox::ClArgs &args) noexcept {
-	nostalgia::registerKeelModules();
 	const auto argSrc = args.getString("src", "");
 	const auto argRomBin = args.getString("rom-bin", "");
 	if (argSrc == "") {
@ -63,7 +63,7 @@ static ox::Error run(const ox::ClArgs &args) noexcept {
 	}
 	ox::Buffer dstBuff(32 * ox::units::MB);
 	oxReturnError(ox::FileSystem32::format(dstBuff.data(), dstBuff.size()));
-	ox::FileSystem32 dst(ox::FileStore32(dstBuff.data(), dstBuff.size()));
+	ox::FileSystem32 dst(dstBuff);
 	oxRequire(ctx, keel::init(ox::make_unique<ox::PassThroughFS>(argSrc), "nost-pack"));
 	keel::TypeStore ts(ctx->rom.get(), "/.nostalgia/type_descriptors");
 	oxReturnError(generateTypes(&ts));
@ -87,16 +87,8 @@ static ox::Error run(const ox::ClArgs &args) noexcept {
 }

 int main(int argc, const char **args) {
-	ox::trace::init();
-#ifdef DEBUG
-	ox::LoggerConn loggerConn;
-	const auto loggerErr = loggerConn.initConn("nost-pack");
-	if (loggerErr) {
-		oxErrf("Could not connect to logger: {} ({}:{})\n", toStr(loggerErr), loggerErr.file, loggerErr.line);
-	} else {
-		ox::trace::setLogger(&loggerConn);
-	}
-#endif
+	OX_INIT_DEBUG_LOGGER(loggerConn, "nost-pack")
+	nostalgia::registerKeelModules();
 	const auto err = run(ox::ClArgs(argc, args));
 	oxAssert(err, "pack failed");
 	return static_cast<int>(err);
--- a/src/studio/applib/include/studioapp/studioapp.hpp
+++ b/src/studio/applib/include/studioapp/studioapp.hpp
@ -12,8 +12,15 @@ namespace studio {

 void registerModule(const studio::Module*) noexcept;

+struct StudioOptions {
+	ox::String appName;
+	ox::String projectDataDir;
+};
+
+int main(StudioOptions&&);
+
 int main(
-		const char *appName,
+		ox::CRStringView appName,
 		ox::String projectDataDir,
 		int argc,
 		const char **argv);
--- a/src/studio/applib/src/main.cpp
+++ b/src/studio/applib/src/main.cpp
@ -5,12 +5,14 @@
 #include <ctime>

 #include <ox/logconn/logconn.hpp>
+#include <ox/logconn/def.hpp>
 #include <ox/std/trace.hpp>
 #include <ox/std/uuid.hpp>
 #include <keel/media.hpp>
 #include <turbine/turbine.hpp>

 #include <studio/context.hpp>
+#include <studioapp/studioapp.hpp>
 #include "studioapp.hpp"

 namespace studio {
@ -61,30 +63,26 @@ static ox::Error runApp(
 }

 int main(
-		const char *appName,
+		ox::CRStringView appName,
 		ox::String projectDataDir,
 		int,
 		const char**) {
-#ifdef DEBUG
-	ox::LoggerConn loggerConn;
-	const auto loggerErr = loggerConn.initConn(appName);
-	if (loggerErr) {
-		oxErrf("Could not connect to logger: {}\n", toStr(loggerErr));
-	} else {
-		ox::trace::setLogger(&loggerConn);
-	}
-#endif
-	ox::trace::init();
-	// run app
+	OX_INIT_DEBUG_LOGGER(loggerConn, appName)
+	// seed UUID generator
 	const auto time = std::time(nullptr);
 	ox::UUID::seedGenerator({
 		static_cast<uint64_t>(time),
 		static_cast<uint64_t>(time << 1)
 	});
+	// run app
 	const auto err = runApp(appName, std::move(projectDataDir), ox::UniquePtr<ox::FileSystem>(nullptr));
 	oxAssert(err, "Something went wrong...");
 	return static_cast<int>(err);
 }

+int main(StudioOptions &&opts, int argc = 0, const char **argv = nullptr) {
+	return main(opts.appName, std::move(opts.projectDataDir), argc, argv);
+}
+
 }

--- a/src/studio/applib/src/newmenu.cpp
+++ b/src/studio/applib/src/newmenu.cpp
@ -57,7 +57,7 @@ void NewMenu::drawNewItemType(turbine::Context *ctx) noexcept {
 	drawWindow(ctx, &m_open, [this] {
 		auto items = ox_malloca(m_types.size() * sizeof(const char*), const char*, nullptr);
 		for (auto i = 0u; const auto &im : m_types) {
-			items[i] = im->name.c_str();
+			items.get()[i] = im->name.c_str();
 			++i;
 		}
 		ImGui::ListBox("Item Type", &m_selectedType, items.get(), static_cast<int>(m_types.size()));
--- a/src/studio/applib/src/projectexplorer.cpp
+++ b/src/studio/applib/src/projectexplorer.cpp
@ -11,7 +11,7 @@
 namespace studio {

 static ox::Result<ox::UniquePtr<ProjectTreeModel>>
-buildProjectTreeModel(ProjectExplorer *explorer, ox::CRStringView name, ox::CRStringView path, ProjectTreeModel *parent) noexcept {
+buildProjectTreeModel(ProjectExplorer *explorer, ox::String name, ox::CRStringView path, ProjectTreeModel *parent) noexcept {
 	const auto fs = explorer->romFs();
 	oxRequire(stat, fs->stat(path));
 	auto out = ox::make_unique<ProjectTreeModel>(explorer, name, parent);
--- a/src/studio/applib/src/studioapp.cpp
+++ b/src/studio/applib/src/studioapp.cpp
@ -305,7 +305,7 @@ ox::Error StudioUI::openProject(ox::CRStringView path) noexcept {
 	oxRequireM(fs, keel::loadRomFs(path));
 	oxReturnError(keel::setRomFs(&m_ctx->keelCtx, std::move(fs)));
 	turbine::setWindowTitle(*m_ctx, ox::sfmt("{} - {}", m_ctx->keelCtx.appName, path));
-	m_project = ox::make_unique<studio::Project>(&m_ctx->keelCtx, path, m_projectDir);
+	m_project = ox::make_unique<studio::Project>(&m_ctx->keelCtx, ox::String(path), m_projectDir);
 	auto sctx = applicationData<studio::StudioContext>(*m_ctx);
 	sctx->project = m_project.get();
 	m_project->fileAdded.connect(m_projectExplorer.get(), &ProjectExplorer::refreshProjectTreeModel);
@ -313,7 +313,7 @@ ox::Error StudioUI::openProject(ox::CRStringView path) noexcept {
 	m_openFiles.clear();
 	m_editors.clear();
 	studio::editConfig<StudioConfig>(&m_ctx->keelCtx, [&](StudioConfig *config) {
-		config->projectPath = path;
+		config->projectPath = ox::String(path);
 		config->openFiles.clear();
 	});
 	return m_projectExplorer->refreshProjectTreeModel();
@ -324,7 +324,9 @@ ox::Error StudioUI::openFile(ox::CRStringView path) noexcept {
 }

 ox::Error StudioUI::openFileActiveTab(ox::CRStringView path, bool makeActiveTab) noexcept {
-	if (m_openFiles.contains(path)) {
+	// Warning: StringView to String
+	auto const pathStr = ox::String(path);
+	if (m_openFiles.contains(pathStr)) {
 		for (auto &e : m_editors) {
 			if (makeActiveTab && e->itemName() == path) {
 				m_activeEditor = e.get();
@ -334,7 +336,7 @@ ox::Error StudioUI::openFileActiveTab(ox::CRStringView path, bool makeActiveTab)
 		}
 		return OxError(0);
 	}
-	oxRequire(ext, studio::fileExt(path));
+	oxRequire(ext, studio::fileExt(path).to<ox::String>([](auto const&v) {return ox::String(v);}));
 	// create Editor
 	studio::BaseEditor *editor = nullptr;
 	if (!m_editorMakers.contains(ext)) {
@ -363,7 +365,7 @@ ox::Error StudioUI::openFileActiveTab(ox::CRStringView path, bool makeActiveTab)
 	}
 	// save to config
 	studio::editConfig<StudioConfig>(&m_ctx->keelCtx, [&](StudioConfig *config) {
-		if (!config->openFiles.contains(path)) {
+		if (!config->openFiles.contains(pathStr)) {
 			config->openFiles.emplace_back(path);
 		}
 	});
--- a/src/studio/applib/src/studioapp.hpp
+++ b/src/studio/applib/src/studioapp.hpp
@ -88,10 +88,4 @@ class StudioUI: public ox::SignalHandler {
 		ox::Error closeFile(const ox::String &path) noexcept;
 };

-int main(
-		const char *appName,
-		ox::String projectDataDir,
-		[[maybe_unused]] int argc,
-		[[maybe_unused]] const char **argv);
-
 }
--- a/src/studio/modlib/src/project.cpp
+++ b/src/studio/modlib/src/project.cpp
@ -57,7 +57,8 @@ bool Project::exists(ox::CRStringView path) const noexcept {
 }

 const ox::Vector<ox::String> &Project::fileList(ox::CRStringView ext) noexcept {
-	return m_fileExtFileMap[ext];
+	// Warning: StringView to String
+	return m_fileExtFileMap[ox::String(ext)];
 }

 void Project::buildFileIndex() noexcept {
@ -80,7 +81,8 @@ void Project::indexFile(ox::CRStringView path) noexcept {
 	if (err) {
 		return;
 	}
-	m_fileExtFileMap[ext].emplace_back(path);
+	// Warning: StringView to String
+	m_fileExtFileMap[ox::String(ext)].emplace_back(path);
 }

 ox::Error Project::writeBuff(const ox::StringView &path, const ox::Buffer &buff) noexcept {
@ -88,7 +90,8 @@ ox::Error Project::writeBuff(const ox::StringView &path, const ox::Buffer &buff)
 	ox::Buffer outBuff;
 	outBuff.reserve(buff.size() + HdrSz);
 	ox::BufferWriter writer(&outBuff);
-	const auto [uuid, err] =  m_ctx->pathToUuid.at(path);
+	// Warning: StringView to String
+	const auto [uuid, err] =  m_ctx->pathToUuid.at(ox::String(path));
 	if (!err) {
 		oxReturnError(keel::writeUuidHeader(writer, *uuid));
 	}
--- a/src/turbine/glfw/clipboard.cpp
+++ b/src/turbine/glfw/clipboard.cpp
@ -21,7 +21,7 @@ void setClipboardText(Context &ctx, ox::CRStringView text) noexcept {
 	auto &gctx = static_cast<GlfwContext&>(ctx);
 	auto cstr = ox_malloca(text.bytes() + 1, char);
 	ox_strncpy(cstr.get(), text.data(), text.bytes());
-	glfwSetClipboardString(gctx.window, cstr);
+	glfwSetClipboardString(gctx.window, cstr.get());
 }

 }
--- a/src/turbine/glfw/gfx.cpp
+++ b/src/turbine/glfw/gfx.cpp
@ -220,8 +220,9 @@ ox::Error initGfx(Context &ctx) noexcept {
 	glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
 	auto cstr = ox_malloca(ctx.keelCtx.appName.bytes() + 1, char);
 	ox_strncpy(cstr.get(), ctx.keelCtx.appName.data(), ctx.keelCtx.appName.bytes());
-	constexpr auto Scale = 5;
-	gctx.window = glfwCreateWindow(240 * Scale, 160 * Scale, cstr, nullptr, nullptr);
+	//constexpr auto Scale = 5;
+	//gctx.window = glfwCreateWindow(240 * Scale, 160 * Scale, cstr, nullptr, nullptr);
+	gctx.window = glfwCreateWindow(868, 741, cstr.get(), nullptr, nullptr);
 	if (gctx.window == nullptr) {
 		return OxError(1, "Could not open GLFW window");
 	}
@ -250,7 +251,7 @@ void setWindowTitle(Context &ctx, ox::CRStringView title) noexcept {
 	auto &gctx = glctx(ctx);
 	auto cstr = ox_malloca(title.bytes() + 1, char);
 	ox_strncpy(cstr.get(), title.data(), title.bytes());
-	glfwSetWindowTitle(gctx.window, cstr);
+	glfwSetWindowTitle(gctx.window, cstr.get());
 }

 void focusWindow(Context &ctx) noexcept {
Author	SHA1	Message	Date
Gary Talent	b946e428ad	[keel,nostalgia,turbine] Cleanup	2023-11-23 01:46:11 -06:00
Gary Talent	a84a829769	[ox] Cleanup String/StringView conversions, MallocaPtr	2023-11-23 01:34:16 -06:00