From 85430d323270b83aff1e91837cd716733adce002 Mon Sep 17 00:00:00 2001 From: iTNTPiston Date: Thu, 4 Feb 2021 03:59:38 -0500 Subject: [PATCH 01/13] ksys/evt: Start adding OrderParam --- data/uking_functions.csv | 18 +-- src/KingSystem/Event/CMakeLists.txt | 2 + src/KingSystem/Event/evtEvent.cpp | 7 + src/KingSystem/Event/evtEvent.h | 2 + src/KingSystem/Event/evtManager.h | 2 + src/KingSystem/Event/evtOrderParam.cpp | 173 +++++++++++++++++++++++++ src/KingSystem/Event/evtOrderParam.h | 92 +++++++++++++ 7 files changed, 287 insertions(+), 9 deletions(-) create mode 100644 src/KingSystem/Event/evtOrderParam.cpp create mode 100644 src/KingSystem/Event/evtOrderParam.h diff --git a/data/uking_functions.csv b/data/uking_functions.csv index 2d4350f2..cd616398 100644 --- a/data/uking_functions.csv +++ b/data/uking_functions.csv @@ -75586,19 +75586,19 @@ 0x0000007100db4124,evt::Event::assign,48, 0x0000007100db4154,sub_7100DB4154,1680, 0x0000007100db47e4,ksys::evt::OrderParam::ctor,36, -0x0000007100db4808,sub_7100DB4808,20, -0x0000007100db481c,sub_7100DB481C,284, -0x0000007100db4938,sub_7100DB4938,52, +0x0000007100db4808,ksys::evt::OrderParam::dtor,20, +0x0000007100db481c,ksys::evt::OrderParam::uninitialize,284,_ZN4ksys3evt10OrderParam12uninitializeEv +0x0000007100db4938,ksys::evt::OrderParam::dtorDelete,52, 0x0000007100db496c,ksys::evt::OrderParam::doAssign,1160, 0x0000007100db4df4,ksys::evt::OrderParam::assign,48, -0x0000007100db4e24,ksys::evt::OrderParam::initialize,332, +0x0000007100db4e24,ksys::evt::OrderParam::initialize,332,_ZN4ksys3evt10OrderParam10initializeEi? 0x0000007100db4f70,ksys::evt::OrderParam::addParamInt,220, 0x0000007100db504c,ksys::evt::OrderParam::addParamStr,412, -0x0000007100db51e8,ksys::evt::OrderParam::tryAlloc_,944, -0x0000007100db5598,ksys::evt::OrderParam::addParamActor,240, -0x0000007100db5688,ksys::evt::OrderParam::addInt,176, -0x0000007100db5738,ksys::evt::OrderParam::getParameter,176, -0x0000007100db57e8,ksys::evt::OrderParam::x_1,208, +0x0000007100db51e8,ksys::evt::OrderParam::tryAlloc_,944,_ZN4ksys3evt10OrderParam8tryAllocENS0_14OrderParamTypeEjRN4sead14SafeStringBaseIcEE? +0x0000007100db5598,ksys::evt::OrderParam::addParamActor,240,_ZN4ksys3evt10OrderParam13addParamActorERNS_3act8BaseProcERN4sead14SafeStringBaseIcEE? +0x0000007100db5688,ksys::evt::OrderParam::getIntByName,176,_ZN4ksys3evt10OrderParam12getIntByNameERKN4sead14SafeStringBaseIcEEPPj? +0x0000007100db5738,ksys::evt::OrderParam::getStringByName,176,_ZN4ksys3evt10OrderParam15getStringByNameERKN4sead14SafeStringBaseIcEEPPS4_? +0x0000007100db57e8,ksys::evt::OrderParam::getArrayByName,208,_ZN4ksys3evt10OrderParam14getArrayByNameERKN4sead14SafeStringBaseIcEEPPvPj? 0x0000007100db58b8,evt::EventFlowBase::ctor,2140, 0x0000007100db6114,_ZN4sead9SafeArrayINS_15FixedSafeStringILi64EEELi8EEC2Ev,360, 0x0000007100db627c,evt::EventFlowBase::getBaseProcLink,12, diff --git a/src/KingSystem/Event/CMakeLists.txt b/src/KingSystem/Event/CMakeLists.txt index 0de91345..2ba90f45 100644 --- a/src/KingSystem/Event/CMakeLists.txt +++ b/src/KingSystem/Event/CMakeLists.txt @@ -5,4 +5,6 @@ target_sources(uking PRIVATE evtInfoData.h evtManager.cpp evtManager.h + evtOrderParam.cpp + evtOrderParam.h ) diff --git a/src/KingSystem/Event/evtEvent.cpp b/src/KingSystem/Event/evtEvent.cpp index 9577e6a3..8addcda3 100644 --- a/src/KingSystem/Event/evtEvent.cpp +++ b/src/KingSystem/Event/evtEvent.cpp @@ -1 +1,8 @@ #include "KingSystem/Event/evtEvent.h" +#include "KingSystem/Event/evtManager.h" +#include "KingSystem/Event/evtOrderParam.h" + +namespace ksys::evt { + +Event::Event() {} +} // namespace ksys::evt \ No newline at end of file diff --git a/src/KingSystem/Event/evtEvent.h b/src/KingSystem/Event/evtEvent.h index ac6a8a94..3d5c255b 100644 --- a/src/KingSystem/Event/evtEvent.h +++ b/src/KingSystem/Event/evtEvent.h @@ -1,10 +1,12 @@ #pragma once #include +#include #include namespace ksys::evt { +class OrderParam; // TODO class Event { public: diff --git a/src/KingSystem/Event/evtManager.h b/src/KingSystem/Event/evtManager.h index 0850d534..4d192721 100644 --- a/src/KingSystem/Event/evtManager.h +++ b/src/KingSystem/Event/evtManager.h @@ -16,6 +16,8 @@ public: void init(sead::Heap* heap); Event* getActiveEvent() const; + + sead::Heap* mEventHeap; // 0x1d180 }; } // namespace ksys::evt diff --git a/src/KingSystem/Event/evtOrderParam.cpp b/src/KingSystem/Event/evtOrderParam.cpp new file mode 100644 index 00000000..cbf71639 --- /dev/null +++ b/src/KingSystem/Event/evtOrderParam.cpp @@ -0,0 +1,173 @@ +#include "KingSystem/Event/evtOrderParam.h" +#include +#include +#include +#include +#include +#include "KingSystem/ActorSystem/actBaseProcLink.h" + +namespace ksys::evt { + +OrderParam::OrderParam(sead::ExpHeap* heap) { + mHeap = heap; +} + +bool OrderParam::initialize(s32 entry_count) { + sead::FixedSafeString<0x100> error_message; + + error_message.format("[%s] initialize(%d) is failed.", "ksys::evt::OrderParam", entry_count); + uninitialize(); + if (entry_count == 0) + return true; + if (!mHeap) + return false; + if (entry_count < 1) + return false; + if (!mEntries.tryAllocBuffer(entry_count, mHeap)) + return false; + + // I think compiler is unrolling this loop + for (s32 i = 0; i != mEntries.size(); ++i) { + clearEntry(&mEntries[i]); + } + mEntryCount = 0; + mInitialized = true; + return true; +} + +void OrderParam::uninitialize() { + for (s32 i = 0; i < mEntries.size(); i++) { + auto* e = &mEntries[i]; + auto* name_ptr = e->mName; + if (name_ptr) + delete (sead::FixedSafeString<0x20>*)name_ptr; + auto* ptr = e->mPointer; + if (ptr) { + switch (e->mType) { + case OrderParamType::STRING: + delete (sead::FixedSafeString<0x40>*)ptr; + break; + case OrderParamType::INT: + case OrderParamType::INT_2: + delete (u32*)ptr; + break; + case OrderParamType::BYTE: + delete (char*)ptr; + break; + case OrderParamType::ACTOR: + delete (ksys::act::BaseProcLink*)ptr; + break; + case OrderParamType::ARRAY: + mHeap->free(ptr); + break; + default: + break; + } + } + clearEntry(e); + } + mEntries.freeBuffer(); + mEntryCount = 0; + mInitialized = false; +} + +// half done +void OrderParam::addParamActor(ksys::act::BaseProc& actor, sead::SafeString& name) { + u32 hash = sead::HashCRC32::calcStringHash(name.cstr()); + s32 i; + for (i = 0; i < mEntries.size(); i++) { + if (mEntries[i].mHash == hash && mEntries[i].mType == OrderParamType::ACTOR) { + if (!mEntries[i].mPointer) { + break; + } + } + } + + auto* entry = tryAlloc(OrderParamType::ACTOR, 0, name); + if (entry) { + auto* actor_ptr = (ksys::act::BaseProcLink*)entry->mPointer; + if (actor_ptr->acquire(&actor, false)) { + ++this->mEntryCount; + } + } +} +// The three below have 1 pair of instructions swapped + +bool OrderParam::getIntByName(const sead::SafeString& name, u32** out_ptr) { + return tryGetPointerByName(name, (void**)out_ptr, nullptr, OrderParamType::INT); +} + +bool OrderParam::getStringByName(const sead::SafeString& name, sead::SafeString** out_ptr) { + return tryGetPointerByName(name, (void**)out_ptr, nullptr, OrderParamType::STRING); +} + +bool OrderParam::getArrayByName(const sead::SafeString& name, void** out_ptr, u32* out_size) { + return tryGetPointerByName(name, out_ptr, out_size, OrderParamType::ARRAY); +} + +// This one also does not match +OrderParamEntry* OrderParam::tryAlloc(OrderParamType type, u32 size, sead::SafeString& name) { + sead::FixedSafeString<0x100> error_message; + + error_message.format("[%s] tryAlloc_(%d, %d, %s) is failed.", "ksys::evt::OrderParam", type, + size, name.cstr()); + + for (s32 i = 0; i < mEntries.size(); i++) { + auto* e = &mEntries[i]; + + if (!e->mPointer) { + void** in_ptr = &(e->mPointer); + std::nothrow_t nothrow_t; + auto* heap = mHeap; + if (!heap) + return nullptr; + + e->mName = new (heap, nothrow_t) sead::FixedSafeString<0x20>(name); + switch (type) { + case OrderParamType::STRING: + *in_ptr = new (heap, nothrow_t) sead::FixedSafeString<0x40>; + size = sizeof(sead::FixedSafeString<0x40>); + break; + case OrderParamType::INT: + case OrderParamType::INT_2: + *in_ptr = new (heap, nothrow_t) u32(0); + size = sizeof(u32); + break; + + case OrderParamType::BYTE: + *in_ptr = new (heap, nothrow_t) char(0); + size = sizeof(char); + break; + case OrderParamType::ACTOR: + *in_ptr = new (heap, nothrow_t) ksys::act::BaseProcLink; + size = sizeof(ksys::act::BaseProcLink); + break; + case OrderParamType::ARRAY: + *in_ptr = new (heap, nothrow_t) char[size]; + default: + break; + } + e->mSize = size; + if (e->mPointer) { + e->mHash = sead::HashCRC32::calcStringHash(e->mName->cstr()); + e->mType = type; + return e; + } + if (e->mName) + delete e->mName; + // clearEntry(e); + *e = {}; + return nullptr; + // auto* entry = mAllocArray+i; + // if (*in_ptr) { + + //} else { + + //} + } + } + + return nullptr; +} + +} // namespace ksys::evt \ No newline at end of file diff --git a/src/KingSystem/Event/evtOrderParam.h b/src/KingSystem/Event/evtOrderParam.h new file mode 100644 index 00000000..0fc07e74 --- /dev/null +++ b/src/KingSystem/Event/evtOrderParam.h @@ -0,0 +1,92 @@ +#pragma once + +#include +#include +#include +#include +#include "KingSystem/ActorSystem/actBaseProc.h" + +namespace ksys::evt { + +enum class OrderParamType : u16 { + INVALID = 0, + INT = 1, + INT_2 = 2, + STRING = 3, + BYTE = 4, + ACTOR = 5, + ARRAY = 6 + +}; + +struct OrderParamEntry { + u32 mHash = 0; + // u32 _4; alignment gap + sead::SafeString* mName = nullptr; + void* mPointer = nullptr; //_10 + u32 mSize = 0; //_18 + OrderParamType mType = OrderParamType::INVALID; + // u16 _1e; alignment gap +}; + +class OrderParam { + OrderParam(sead::ExpHeap* mHeap); + virtual ~OrderParam(); + +public: + bool initialize(s32 entry_count); + void uninitialize(); + + bool addParamInt(s32 val, const sead::SafeString& key); + void addParamActor(ksys::act::BaseProc& actor, sead::SafeString& name); + OrderParamEntry* tryAlloc(OrderParamType type, u32 size, sead::SafeString& name); + bool getIntByName(const sead::SafeString& name, u32** out_ptr); + bool getStringByName(const sead::SafeString& name, sead::SafeString** out_ptr); + bool getArrayByName(const sead::SafeString& name, void** out_ptr, u32* out_size); + +private: + inline void* getPointerByName(const sead::SafeString& name, OrderParamType type) { + u32 hash = sead::HashCRC32::calcStringHash(name.cstr()); + s32 i; + for (i = 0; i < mEntries.size(); i++) { + if (mEntries[i].mHash == hash && mEntries[i].mType == type) { + return mEntries[i].mPointer; + } + } + return nullptr; + } + inline bool tryGetPointerByName(const sead::SafeString& name, void** out_ptr, u32* out_size, + OrderParamType type) { + u32 hash = sead::HashCRC32::calcStringHash(name.cstr()); + s32 i; + for (i = 0; i < mEntries.size(); i++) { + if (mEntries[i].mHash == hash && mEntries[i].mType == type) { + if (out_size) { + *out_size = mEntries[i].mSize; + } + return tryGetPointer(i, out_ptr); + } + } + return false; + } + inline bool tryGetPointer(s32 i, void** out_ptr) { + auto* ptr = mEntries[i].mPointer; + if (ptr) { + *out_ptr = ptr; // minor diff with scheduling + return true; + } + return false; + } + inline void clearEntry(OrderParamEntry* e) { + e->mHash = 0; + e->mSize = 0; + e->mType = OrderParamType::INVALID; + e->mName = nullptr; + e->mPointer = nullptr; + } + sead::ExpHeap* mHeap; + sead::Buffer mEntries; + u32 mEntryCount = 0; + bool mInitialized = false; +}; +} // namespace ksys::evt \ No newline at end of file From 9c6bec732fa433121c7cbda227ed536af0a9cb91 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A9o=20Lam?= Date: Thu, 4 Feb 2021 18:56:20 +0100 Subject: [PATCH 02/13] ksys/evt: Match OrderParam "get T by name" getters --- data/uking_functions.csv | 6 ++-- src/KingSystem/Event/evtOrderParam.cpp | 22 ++++++++++--- src/KingSystem/Event/evtOrderParam.h | 44 +++++++------------------- 3 files changed, 32 insertions(+), 40 deletions(-) diff --git a/data/uking_functions.csv b/data/uking_functions.csv index cd616398..98e61f37 100644 --- a/data/uking_functions.csv +++ b/data/uking_functions.csv @@ -75596,9 +75596,9 @@ 0x0000007100db504c,ksys::evt::OrderParam::addParamStr,412, 0x0000007100db51e8,ksys::evt::OrderParam::tryAlloc_,944,_ZN4ksys3evt10OrderParam8tryAllocENS0_14OrderParamTypeEjRN4sead14SafeStringBaseIcEE? 0x0000007100db5598,ksys::evt::OrderParam::addParamActor,240,_ZN4ksys3evt10OrderParam13addParamActorERNS_3act8BaseProcERN4sead14SafeStringBaseIcEE? -0x0000007100db5688,ksys::evt::OrderParam::getIntByName,176,_ZN4ksys3evt10OrderParam12getIntByNameERKN4sead14SafeStringBaseIcEEPPj? -0x0000007100db5738,ksys::evt::OrderParam::getStringByName,176,_ZN4ksys3evt10OrderParam15getStringByNameERKN4sead14SafeStringBaseIcEEPPS4_? -0x0000007100db57e8,ksys::evt::OrderParam::getArrayByName,208,_ZN4ksys3evt10OrderParam14getArrayByNameERKN4sead14SafeStringBaseIcEEPPvPj? +0x0000007100db5688,ksys::evt::OrderParam::getIntByName,176,_ZN4ksys3evt10OrderParam12getIntByNameERKN4sead14SafeStringBaseIcEEPPj +0x0000007100db5738,ksys::evt::OrderParam::getStringByName,176,_ZN4ksys3evt10OrderParam15getStringByNameERKN4sead14SafeStringBaseIcEEPPS4_ +0x0000007100db57e8,ksys::evt::OrderParam::getArrayByName,208,_ZN4ksys3evt10OrderParam14getArrayByNameERKN4sead14SafeStringBaseIcEEPPvPj 0x0000007100db58b8,evt::EventFlowBase::ctor,2140, 0x0000007100db6114,_ZN4sead9SafeArrayINS_15FixedSafeStringILi64EEELi8EEC2Ev,360, 0x0000007100db627c,evt::EventFlowBase::getBaseProcLink,12, diff --git a/src/KingSystem/Event/evtOrderParam.cpp b/src/KingSystem/Event/evtOrderParam.cpp index cbf71639..918fca06 100644 --- a/src/KingSystem/Event/evtOrderParam.cpp +++ b/src/KingSystem/Event/evtOrderParam.cpp @@ -91,18 +91,17 @@ void OrderParam::addParamActor(ksys::act::BaseProc& actor, sead::SafeString& nam } } } -// The three below have 1 pair of instructions swapped bool OrderParam::getIntByName(const sead::SafeString& name, u32** out_ptr) { - return tryGetPointerByName(name, (void**)out_ptr, nullptr, OrderParamType::INT); + return getPointerByName(name, out_ptr, nullptr, OrderParamType::INT); } bool OrderParam::getStringByName(const sead::SafeString& name, sead::SafeString** out_ptr) { - return tryGetPointerByName(name, (void**)out_ptr, nullptr, OrderParamType::STRING); + return getPointerByName(name, out_ptr, nullptr, OrderParamType::STRING); } bool OrderParam::getArrayByName(const sead::SafeString& name, void** out_ptr, u32* out_size) { - return tryGetPointerByName(name, out_ptr, out_size, OrderParamType::ARRAY); + return getPointerByName(name, out_ptr, out_size, OrderParamType::ARRAY); } // This one also does not match @@ -170,4 +169,17 @@ OrderParamEntry* OrderParam::tryAlloc(OrderParamType type, u32 size, sead::SafeS return nullptr; } -} // namespace ksys::evt \ No newline at end of file +void* OrderParam::getPointerByName(const sead::SafeString& name, u32* out_size, + OrderParamType type) const { + const u32 hash = sead::HashCRC32::calcStringHash(name); + for (s32 i = 0; i < mEntries.size(); i++) { + if (mEntries[i].mHash == hash && mEntries[i].mType == type) { + if (out_size) + *out_size = mEntries[i].mSize; + return mEntries[i].mPointer; + } + } + return nullptr; +} + +} // namespace ksys::evt diff --git a/src/KingSystem/Event/evtOrderParam.h b/src/KingSystem/Event/evtOrderParam.h index 0fc07e74..11352a33 100644 --- a/src/KingSystem/Event/evtOrderParam.h +++ b/src/KingSystem/Event/evtOrderParam.h @@ -45,38 +45,18 @@ public: bool getArrayByName(const sead::SafeString& name, void** out_ptr, u32* out_size); private: - inline void* getPointerByName(const sead::SafeString& name, OrderParamType type) { - u32 hash = sead::HashCRC32::calcStringHash(name.cstr()); - s32 i; - for (i = 0; i < mEntries.size(); i++) { - if (mEntries[i].mHash == hash && mEntries[i].mType == type) { - return mEntries[i].mPointer; - } - } - return nullptr; - } - inline bool tryGetPointerByName(const sead::SafeString& name, void** out_ptr, u32* out_size, - OrderParamType type) { - u32 hash = sead::HashCRC32::calcStringHash(name.cstr()); - s32 i; - for (i = 0; i < mEntries.size(); i++) { - if (mEntries[i].mHash == hash && mEntries[i].mType == type) { - if (out_size) { - *out_size = mEntries[i].mSize; - } - return tryGetPointer(i, out_ptr); - } - } - return false; - } - inline bool tryGetPointer(s32 i, void** out_ptr) { - auto* ptr = mEntries[i].mPointer; - if (ptr) { - *out_ptr = ptr; // minor diff with scheduling - return true; - } - return false; + void* getPointerByName(const sead::SafeString& name, u32* out_size, OrderParamType type) const; + + template + bool getPointerByName(const sead::SafeString& name, T** out_ptr, u32* out_size, + OrderParamType type) const { + auto* ptr = getPointerByName(name, out_size, type); + if (!ptr) + return false; + *out_ptr = static_cast(ptr); + return true; } + inline void clearEntry(OrderParamEntry* e) { e->mHash = 0; e->mSize = 0; @@ -89,4 +69,4 @@ private: u32 mEntryCount = 0; bool mInitialized = false; }; -} // namespace ksys::evt \ No newline at end of file +} // namespace ksys::evt From d4b49662e160330c8baf01e1bb6d387a5db2b543 Mon Sep 17 00:00:00 2001 From: iTNTPiston Date: Sat, 6 Feb 2021 01:58:06 -0500 Subject: [PATCH 03/13] ksys/evt: Add OrderParam "add param" and assign functions --- data/uking_functions.csv | 12 +- src/KingSystem/Event/evtOrderParam.cpp | 153 +++++++++++++++++++++---- src/KingSystem/Event/evtOrderParam.h | 36 ++++-- 3 files changed, 167 insertions(+), 34 deletions(-) diff --git a/data/uking_functions.csv b/data/uking_functions.csv index 98e61f37..31dfc19f 100644 --- a/data/uking_functions.csv +++ b/data/uking_functions.csv @@ -75589,13 +75589,13 @@ 0x0000007100db4808,ksys::evt::OrderParam::dtor,20, 0x0000007100db481c,ksys::evt::OrderParam::uninitialize,284,_ZN4ksys3evt10OrderParam12uninitializeEv 0x0000007100db4938,ksys::evt::OrderParam::dtorDelete,52, -0x0000007100db496c,ksys::evt::OrderParam::doAssign,1160, -0x0000007100db4df4,ksys::evt::OrderParam::assign,48, +0x0000007100db496c,ksys::evt::OrderParam::doAssign,1160,_ZN4ksys3evt10OrderParam8doAssignEPS1_ +0x0000007100db4df4,ksys::evt::OrderParam::assign,48,_ZN4ksys3evt10OrderParam6assignEPS1_ 0x0000007100db4e24,ksys::evt::OrderParam::initialize,332,_ZN4ksys3evt10OrderParam10initializeEi? -0x0000007100db4f70,ksys::evt::OrderParam::addParamInt,220, -0x0000007100db504c,ksys::evt::OrderParam::addParamStr,412, -0x0000007100db51e8,ksys::evt::OrderParam::tryAlloc_,944,_ZN4ksys3evt10OrderParam8tryAllocENS0_14OrderParamTypeEjRN4sead14SafeStringBaseIcEE? -0x0000007100db5598,ksys::evt::OrderParam::addParamActor,240,_ZN4ksys3evt10OrderParam13addParamActorERNS_3act8BaseProcERN4sead14SafeStringBaseIcEE? +0x0000007100db4f70,ksys::evt::OrderParam::addParamInt,220,_ZN4ksys3evt10OrderParam11addParamIntEiRKN4sead14SafeStringBaseIcEE +0x0000007100db504c,ksys::evt::OrderParam::addParamString,412,_ZN4ksys3evt10OrderParam14addParamStringERKN4sead14SafeStringBaseIcEES6_ +0x0000007100db51e8,ksys::evt::OrderParam::tryAlloc_,944,_ZN4ksys3evt10OrderParam8tryAllocENS0_14OrderParamTypeEjRKN4sead14SafeStringBaseIcEE? +0x0000007100db5598,ksys::evt::OrderParam::addParamActor,240,_ZN4ksys3evt10OrderParam13addParamActorEPNS_3act8BaseProcERN4sead14SafeStringBaseIcEE 0x0000007100db5688,ksys::evt::OrderParam::getIntByName,176,_ZN4ksys3evt10OrderParam12getIntByNameERKN4sead14SafeStringBaseIcEEPPj 0x0000007100db5738,ksys::evt::OrderParam::getStringByName,176,_ZN4ksys3evt10OrderParam15getStringByNameERKN4sead14SafeStringBaseIcEEPPS4_ 0x0000007100db57e8,ksys::evt::OrderParam::getArrayByName,208,_ZN4ksys3evt10OrderParam14getArrayByNameERKN4sead14SafeStringBaseIcEEPPvPj diff --git a/src/KingSystem/Event/evtOrderParam.cpp b/src/KingSystem/Event/evtOrderParam.cpp index 918fca06..0d4d0b64 100644 --- a/src/KingSystem/Event/evtOrderParam.cpp +++ b/src/KingSystem/Event/evtOrderParam.cpp @@ -71,41 +71,142 @@ void OrderParam::uninitialize() { mInitialized = false; } -// half done -void OrderParam::addParamActor(ksys::act::BaseProc& actor, sead::SafeString& name) { - u32 hash = sead::HashCRC32::calcStringHash(name.cstr()); - s32 i; - for (i = 0; i < mEntries.size(); i++) { - if (mEntries[i].mHash == hash && mEntries[i].mType == OrderParamType::ACTOR) { - if (!mEntries[i].mPointer) { - break; +const OrderParamEntry* OrderParam::getParam(const s32 index) const { + sead::FixedSafeString<0x100> error_message; + + error_message.format("[%s] getParam(%d) is failed.", "ksys::evt::OrderParam", index); + if ((u32)std::max(0, mEntries.size()) > (u32)index) { + return &mEntries[index]; + } else { + return nullptr; + } +} +OrderParam* OrderParam::assign(OrderParam* other) { + if (this != other) { + doAssign(other); + } + return this; +} + +bool OrderParam::doAssign(OrderParam* other) { + if (this == other) + return true; + if (!initialize(std::max(0, other->mEntries.size()))) + return false; + for (s32 i = 0; i < mEntries.size(); i++) { + auto* other_entry = other->getParam(i); + if (other_entry) { + auto* other_ptr = other_entry->mPointer; + auto* other_name = other_entry->mName; + ksys::act::BaseProcLink* link_ptr; + ksys::act::BaseProc* actor_ptr; + if (other_ptr && other_name) { + switch (other_entry->mType) { + case OrderParamType::INT: + if (!addParamInt(*static_cast(other_ptr), *other_name)) + return false; + break; + case OrderParamType::INT_2: + if (!addParamInt2(*static_cast(other_ptr), *other_name)) + return false; + break; + case OrderParamType::STRING: + if (!addParamString(*static_cast(other_ptr), *other_name)) + return false; + break; + case OrderParamType::BYTE: + if (!addParamByte(*static_cast(other_ptr), *other_name)) + return false; + break; + case OrderParamType::ACTOR: + link_ptr = static_cast(other_ptr); + actor_ptr = + sead::DynamicCast(link_ptr->getProc(nullptr, nullptr)); + if (!addParamActor(actor_ptr, *other_name)) + return false; + break; + case OrderParamType::ARRAY: + if (!addParamArray(static_cast(other_ptr), other_entry->mSize, + *other_name)) + return false; + break; + default: + break; + } } } } + return true; +} - auto* entry = tryAlloc(OrderParamType::ACTOR, 0, name); - if (entry) { - auto* actor_ptr = (ksys::act::BaseProcLink*)entry->mPointer; - if (actor_ptr->acquire(&actor, false)) { - ++this->mEntryCount; - } - } +bool OrderParam::addParamInt(s32 val, const sead::SafeString& name) { + auto* entry_ptr = tryAllocParam(name, OrderParamType::INT); + if (!entry_ptr) + return false; + *entry_ptr = val; + ++mEntryCount; + return true; +} + +bool OrderParam::addParamInt2(s32 val, const sead::SafeString& name) { + auto* entry_ptr = tryAllocParam(name, OrderParamType::INT_2); + if (!entry_ptr) + return false; + *entry_ptr = val; + ++mEntryCount; + return true; +} +bool OrderParam::addParamString(const sead::SafeString& val, const sead::SafeString& name) { + auto* entry_ptr = tryAllocParam(name, OrderParamType::STRING); + if (!entry_ptr) + return false; + entry_ptr->copy(val); + ++mEntryCount; + return true; +} + +bool OrderParam::addParamByte(char val, const sead::SafeString& name) { + auto* entry_ptr = tryAllocParam(name, OrderParamType::BYTE); + if (!entry_ptr) + return false; + *entry_ptr = val; + ++mEntryCount; + return true; +} + +bool OrderParam::addParamActor(ksys::act::BaseProc* actor, sead::SafeString& name) { + auto* entry_ptr = tryAllocParam(name, OrderParamType::ACTOR); + if (!entry_ptr) + return false; + if (!entry_ptr->acquire(actor, false)) + return false; + ++mEntryCount; + return true; +} + +bool OrderParam::addParamArray(char* array, u32 size, sead::SafeString& name) { + auto* entry_ptr = tryAllocParam(name, OrderParamType::ARRAY, size); + if (!entry_ptr) + return false; + std::memcpy(entry_ptr, array, size); + ++mEntryCount; + return true; } bool OrderParam::getIntByName(const sead::SafeString& name, u32** out_ptr) { - return getPointerByName(name, out_ptr, nullptr, OrderParamType::INT); + return getPointerByName(name, out_ptr, OrderParamType::INT); } bool OrderParam::getStringByName(const sead::SafeString& name, sead::SafeString** out_ptr) { - return getPointerByName(name, out_ptr, nullptr, OrderParamType::STRING); + return getPointerByName(name, out_ptr, OrderParamType::STRING); } bool OrderParam::getArrayByName(const sead::SafeString& name, void** out_ptr, u32* out_size) { - return getPointerByName(name, out_ptr, out_size, OrderParamType::ARRAY); + return getPointerByName(name, out_ptr, OrderParamType::ARRAY, out_size); } // This one also does not match -OrderParamEntry* OrderParam::tryAlloc(OrderParamType type, u32 size, sead::SafeString& name) { +OrderParamEntry* OrderParam::tryAlloc(OrderParamType type, u32 size, const sead::SafeString& name) { sead::FixedSafeString<0x100> error_message; error_message.format("[%s] tryAlloc_(%d, %d, %s) is failed.", "ksys::evt::OrderParam", type, @@ -169,8 +270,18 @@ OrderParamEntry* OrderParam::tryAlloc(OrderParamType type, u32 size, sead::SafeS return nullptr; } -void* OrderParam::getPointerByName(const sead::SafeString& name, u32* out_size, - OrderParamType type) const { +// OrderParamEntry* OrderParam::getEntryByName(const sead::SafeString& name, OrderParamType type) { +// const u32 hash = sead::HashCRC32::calcStringHash(name); +// for (s32 i = 0; i < mEntries.size(); i++) { +// if (mEntries[i].mHash == hash && mEntries[i].mType == type) { +// return &mEntries[i]; +// } +// } +// return nullptr; +// } + +void* OrderParam::getPointerByName(const sead::SafeString& name, OrderParamType type, + u32* out_size) const { const u32 hash = sead::HashCRC32::calcStringHash(name); for (s32 i = 0; i < mEntries.size(); i++) { if (mEntries[i].mHash == hash && mEntries[i].mType == type) { diff --git a/src/KingSystem/Event/evtOrderParam.h b/src/KingSystem/Event/evtOrderParam.h index 11352a33..5eff171c 100644 --- a/src/KingSystem/Event/evtOrderParam.h +++ b/src/KingSystem/Event/evtOrderParam.h @@ -36,27 +36,49 @@ class OrderParam { public: bool initialize(s32 entry_count); void uninitialize(); + OrderParam* assign(OrderParam* other); - bool addParamInt(s32 val, const sead::SafeString& key); - void addParamActor(ksys::act::BaseProc& actor, sead::SafeString& name); - OrderParamEntry* tryAlloc(OrderParamType type, u32 size, sead::SafeString& name); + inline const OrderParamEntry* getParam(const s32 index) const; + bool addParamInt(s32 val, const sead::SafeString& name); + bool addParamInt2(s32 val, const sead::SafeString& name); + bool addParamString(const sead::SafeString& val, const sead::SafeString& name); + bool addParamByte(char val, const sead::SafeString& name); + bool addParamActor(ksys::act::BaseProc* actor, sead::SafeString& name); + bool addParamArray(char* array, u32 size, sead::SafeString& name); + + OrderParamEntry* tryAlloc(OrderParamType type, u32 size, const sead::SafeString& name); bool getIntByName(const sead::SafeString& name, u32** out_ptr); bool getStringByName(const sead::SafeString& name, sead::SafeString** out_ptr); bool getArrayByName(const sead::SafeString& name, void** out_ptr, u32* out_size); private: - void* getPointerByName(const sead::SafeString& name, u32* out_size, OrderParamType type) const; + bool doAssign(OrderParam* other); + // OrderParamEntry* getEntryByName(const sead::SafeString& name, OrderParamType type); + void* getPointerByName(const sead::SafeString& name, OrderParamType type, + u32* out_size = nullptr) const; template - bool getPointerByName(const sead::SafeString& name, T** out_ptr, u32* out_size, - OrderParamType type) const { - auto* ptr = getPointerByName(name, out_size, type); + bool getPointerByName(const sead::SafeString& name, T** out_ptr, OrderParamType type, + u32* out_size = nullptr) const { + auto* ptr = getPointerByName(name, type, out_size); if (!ptr) return false; *out_ptr = static_cast(ptr); return true; } + template + T* tryAllocParam(const sead::SafeString& name, OrderParamType type, u32 size = 0) { + auto* ptr = getPointerByName(name, type); + if (ptr) + return nullptr; + + auto* entry = tryAlloc(type, size, name); + if (!entry || !(entry->mPointer)) + return nullptr; + return static_cast(entry->mPointer); + } + inline void clearEntry(OrderParamEntry* e) { e->mHash = 0; e->mSize = 0; From a16f01aed7b6b40b1e48f0e33ab9d10319a26965 Mon Sep 17 00:00:00 2001 From: iTNTPiston Date: Sat, 6 Feb 2021 19:25:25 -0500 Subject: [PATCH 04/13] ksys/evt: Add OrderParam ctor and dtor --- data/uking_functions.csv | 6 +++--- src/KingSystem/Event/evtOrderParam.cpp | 4 ++++ workflow.sh | 2 +- 3 files changed, 8 insertions(+), 4 deletions(-) diff --git a/data/uking_functions.csv b/data/uking_functions.csv index 31dfc19f..cfbafd0f 100644 --- a/data/uking_functions.csv +++ b/data/uking_functions.csv @@ -75585,10 +75585,10 @@ 0x0000007100db3ffc,evt::Event::doAssign,296, 0x0000007100db4124,evt::Event::assign,48, 0x0000007100db4154,sub_7100DB4154,1680, -0x0000007100db47e4,ksys::evt::OrderParam::ctor,36, -0x0000007100db4808,ksys::evt::OrderParam::dtor,20, +0x0000007100db47e4,ksys::evt::OrderParam::ctor,36,_ZN4ksys3evt10OrderParamC1EPN4sead7ExpHeapE +0x0000007100db4808,ksys::evt::OrderParam::dtor,20,_ZN4ksys3evt10OrderParamD1Ev 0x0000007100db481c,ksys::evt::OrderParam::uninitialize,284,_ZN4ksys3evt10OrderParam12uninitializeEv -0x0000007100db4938,ksys::evt::OrderParam::dtorDelete,52, +0x0000007100db4938,ksys::evt::OrderParam::dtorDelete,52,_ZN4ksys3evt10OrderParamD0Ev 0x0000007100db496c,ksys::evt::OrderParam::doAssign,1160,_ZN4ksys3evt10OrderParam8doAssignEPS1_ 0x0000007100db4df4,ksys::evt::OrderParam::assign,48,_ZN4ksys3evt10OrderParam6assignEPS1_ 0x0000007100db4e24,ksys::evt::OrderParam::initialize,332,_ZN4ksys3evt10OrderParam10initializeEi? diff --git a/src/KingSystem/Event/evtOrderParam.cpp b/src/KingSystem/Event/evtOrderParam.cpp index 0d4d0b64..46d4f6a1 100644 --- a/src/KingSystem/Event/evtOrderParam.cpp +++ b/src/KingSystem/Event/evtOrderParam.cpp @@ -12,6 +12,10 @@ OrderParam::OrderParam(sead::ExpHeap* heap) { mHeap = heap; } +OrderParam::~OrderParam() { + uninitialize(); +} + bool OrderParam::initialize(s32 entry_count) { sead::FixedSafeString<0x100> error_message; diff --git a/workflow.sh b/workflow.sh index 4f89dae9..8e0cee7b 100755 --- a/workflow.sh +++ b/workflow.sh @@ -6,7 +6,7 @@ # Diff a function (in this example, OrderParam::doAssign, -v is equivalent to --source in diff.py) # ./workflow.sh diff -v _ZN4ksys3evt10OrderParam13addParamActorEPNS_3act8BaseProcERN4sead14SafeStringBaseIcEE # Search for mangle name and diff (-f turns off interaction) -# ./workflow.sh mad -v -f _ZN4ksys3evt10OrderParam13addParamActorEPNS_3act8BaseProcERN4sead14SafeStringBaseIcEE +# ./workflow.sh mad -v -f orderparam::doassign # Get ready to pr # ./workflow.sh check From 6ef151ac1f17c0e33dcb4bf29d12e2500ca03db4 Mon Sep 17 00:00:00 2001 From: iTNTPiston Date: Sat, 6 Feb 2021 22:35:23 -0500 Subject: [PATCH 05/13] ksys/evt: Fix OrderParam tryAlloc loop --- src/KingSystem/Event/evtOrderParam.cpp | 126 +++++++++++-------------- src/KingSystem/Event/evtOrderParam.h | 20 ++-- 2 files changed, 71 insertions(+), 75 deletions(-) diff --git a/src/KingSystem/Event/evtOrderParam.cpp b/src/KingSystem/Event/evtOrderParam.cpp index 46d4f6a1..999598cd 100644 --- a/src/KingSystem/Event/evtOrderParam.cpp +++ b/src/KingSystem/Event/evtOrderParam.cpp @@ -21,18 +21,16 @@ bool OrderParam::initialize(s32 entry_count) { error_message.format("[%s] initialize(%d) is failed.", "ksys::evt::OrderParam", entry_count); uninitialize(); - if (entry_count == 0) + if (!entry_count) return true; if (!mHeap) return false; - if (entry_count < 1) - return false; if (!mEntries.tryAllocBuffer(entry_count, mHeap)) return false; - // I think compiler is unrolling this loop - for (s32 i = 0; i != mEntries.size(); ++i) { - clearEntry(&mEntries[i]); + for (s32 i = 0; i < entry_count; i++) { + clearEntry(&mEntries[i]); // no matter what I do, the compiler unrolls the first 2 + // iterations out of the loop } mEntryCount = 0; mInitialized = true; @@ -208,81 +206,71 @@ bool OrderParam::getStringByName(const sead::SafeString& name, sead::SafeString* bool OrderParam::getArrayByName(const sead::SafeString& name, void** out_ptr, u32* out_size) { return getPointerByName(name, out_ptr, OrderParamType::ARRAY, out_size); } - -// This one also does not match +OrderParamEntry* OrderParam::getFreeEntry() { + for (s32 i = 0; i < mEntries.size(); i++) { + auto* entry = &mEntries[i]; + if (!entry->mPointer) { + return entry; + } + } + return nullptr; +} +// This one does not match OrderParamEntry* OrderParam::tryAlloc(OrderParamType type, u32 size, const sead::SafeString& name) { sead::FixedSafeString<0x100> error_message; error_message.format("[%s] tryAlloc_(%d, %d, %s) is failed.", "ksys::evt::OrderParam", type, size, name.cstr()); - for (s32 i = 0; i < mEntries.size(); i++) { - auto* e = &mEntries[i]; + OrderParamEntry* entry = getFreeEntry(); // inlining here fixed the for loop - if (!e->mPointer) { - void** in_ptr = &(e->mPointer); - std::nothrow_t nothrow_t; - auto* heap = mHeap; - if (!heap) - return nullptr; + if (!entry) + return nullptr; + auto* heap = mHeap; + if (!heap) + return nullptr; + std::nothrow_t nothrow; - e->mName = new (heap, nothrow_t) sead::FixedSafeString<0x20>(name); - switch (type) { - case OrderParamType::STRING: - *in_ptr = new (heap, nothrow_t) sead::FixedSafeString<0x40>; - size = sizeof(sead::FixedSafeString<0x40>); - break; - case OrderParamType::INT: - case OrderParamType::INT_2: - *in_ptr = new (heap, nothrow_t) u32(0); - size = sizeof(u32); - break; + entry->mName = + new (heap, nothrow) sead::FixedSafeString<0x20>(name); // scheduling mismatches here + // entry->mName = new_name; + // inlining here doesn't fix the mismatch - case OrderParamType::BYTE: - *in_ptr = new (heap, nothrow_t) char(0); - size = sizeof(char); - break; - case OrderParamType::ACTOR: - *in_ptr = new (heap, nothrow_t) ksys::act::BaseProcLink; - size = sizeof(ksys::act::BaseProcLink); - break; - case OrderParamType::ARRAY: - *in_ptr = new (heap, nothrow_t) char[size]; - default: - break; - } - e->mSize = size; - if (e->mPointer) { - e->mHash = sead::HashCRC32::calcStringHash(e->mName->cstr()); - e->mType = type; - return e; - } - if (e->mName) - delete e->mName; - // clearEntry(e); - *e = {}; - return nullptr; - // auto* entry = mAllocArray+i; - // if (*in_ptr) { - - //} else { - - //} - } + switch (type) { + case OrderParamType::INT: + case OrderParamType::INT_2: + doAlloc(entry, new (heap, nothrow) s32(0)); + break; + case OrderParamType::STRING: + doAlloc(entry, + new (heap, nothrow) sead::FixedSafeString<0x40>); // scheduling mismatches here + break; + case OrderParamType::BYTE: + doAlloc(entry, new (heap, nothrow) char(0)); + break; + case OrderParamType::ACTOR: + doAlloc(entry, new (heap, nothrow) ksys::act::BaseProcLink); + break; + case OrderParamType::ARRAY: + doAlloc(entry, new (heap, nothrow) char[size], size); + break; + default: + break; } - return nullptr; -} + auto* ptr = entry->mPointer; -// OrderParamEntry* OrderParam::getEntryByName(const sead::SafeString& name, OrderParamType type) { -// const u32 hash = sead::HashCRC32::calcStringHash(name); -// for (s32 i = 0; i < mEntries.size(); i++) { -// if (mEntries[i].mHash == hash && mEntries[i].mType == type) { -// return &mEntries[i]; -// } -// } -// return nullptr; -// } + if (ptr) { + entry->mHash = sead::HashCRC32::calcStringHash(*entry->mName); + entry->mType = type; + } else { + if (entry->mName) + delete entry->mName; + clearEntry(entry); + entry = nullptr; + } + return entry; +} void* OrderParam::getPointerByName(const sead::SafeString& name, OrderParamType type, u32* out_size) const { diff --git a/src/KingSystem/Event/evtOrderParam.h b/src/KingSystem/Event/evtOrderParam.h index 5eff171c..52a7295c 100644 --- a/src/KingSystem/Event/evtOrderParam.h +++ b/src/KingSystem/Event/evtOrderParam.h @@ -20,12 +20,12 @@ enum class OrderParamType : u16 { }; struct OrderParamEntry { - u32 mHash = 0; + u32 mHash; // u32 _4; alignment gap - sead::SafeString* mName = nullptr; - void* mPointer = nullptr; //_10 - u32 mSize = 0; //_18 - OrderParamType mType = OrderParamType::INVALID; + sead::SafeString* mName; + void* mPointer; //_10 + u32 mSize; //_18 + OrderParamType mType; // u16 _1e; alignment gap }; @@ -53,7 +53,7 @@ public: private: bool doAssign(OrderParam* other); - // OrderParamEntry* getEntryByName(const sead::SafeString& name, OrderParamType type); + OrderParamEntry* getFreeEntry(); void* getPointerByName(const sead::SafeString& name, OrderParamType type, u32* out_size = nullptr) const; @@ -78,6 +78,13 @@ private: return nullptr; return static_cast(entry->mPointer); } + template + void doAlloc(OrderParamEntry* e, T* ptr, u32 size = sizeof(T)) { + //*size_ptr = sizeof(T); + e->mPointer = ptr; + e->mSize = size; + // return sizeof(T); + } inline void clearEntry(OrderParamEntry* e) { e->mHash = 0; @@ -86,6 +93,7 @@ private: e->mName = nullptr; e->mPointer = nullptr; } + sead::ExpHeap* mHeap; sead::Buffer mEntries; u32 mEntryCount = 0; From f41d668cff4998259880529f4f188eb2f9c9e9c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A9o=20Lam?= Date: Sun, 7 Feb 2021 11:41:13 +0100 Subject: [PATCH 06/13] ksys/evt: Add missing cast Enum classes need to be casted before being passed to dumb C-style variadic functions like format() --- src/KingSystem/Event/evtOrderParam.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/KingSystem/Event/evtOrderParam.cpp b/src/KingSystem/Event/evtOrderParam.cpp index 999598cd..2ae33304 100644 --- a/src/KingSystem/Event/evtOrderParam.cpp +++ b/src/KingSystem/Event/evtOrderParam.cpp @@ -219,8 +219,8 @@ OrderParamEntry* OrderParam::getFreeEntry() { OrderParamEntry* OrderParam::tryAlloc(OrderParamType type, u32 size, const sead::SafeString& name) { sead::FixedSafeString<0x100> error_message; - error_message.format("[%s] tryAlloc_(%d, %d, %s) is failed.", "ksys::evt::OrderParam", type, - size, name.cstr()); + error_message.format("[%s] tryAlloc_(%d, %d, %s) is failed.", "ksys::evt::OrderParam", + static_cast(type), size, name.cstr()); OrderParamEntry* entry = getFreeEntry(); // inlining here fixed the for loop From 37d4a0695cb941078f00d0fd6958ce6fa1b51616 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A9o=20Lam?= Date: Sun, 7 Feb 2021 14:55:57 +0100 Subject: [PATCH 07/13] ksys/evt: Fix matching issue in OrderParam::tryAlloc --- data/uking_functions.csv | 2 +- src/KingSystem/Event/evtOrderParam.cpp | 26 +++++++++++++------------- src/KingSystem/Event/evtOrderParam.h | 7 ------- 3 files changed, 14 insertions(+), 21 deletions(-) diff --git a/data/uking_functions.csv b/data/uking_functions.csv index cfbafd0f..ac83bfb2 100644 --- a/data/uking_functions.csv +++ b/data/uking_functions.csv @@ -75594,7 +75594,7 @@ 0x0000007100db4e24,ksys::evt::OrderParam::initialize,332,_ZN4ksys3evt10OrderParam10initializeEi? 0x0000007100db4f70,ksys::evt::OrderParam::addParamInt,220,_ZN4ksys3evt10OrderParam11addParamIntEiRKN4sead14SafeStringBaseIcEE 0x0000007100db504c,ksys::evt::OrderParam::addParamString,412,_ZN4ksys3evt10OrderParam14addParamStringERKN4sead14SafeStringBaseIcEES6_ -0x0000007100db51e8,ksys::evt::OrderParam::tryAlloc_,944,_ZN4ksys3evt10OrderParam8tryAllocENS0_14OrderParamTypeEjRKN4sead14SafeStringBaseIcEE? +0x0000007100db51e8,ksys::evt::OrderParam::tryAlloc_,944,_ZN4ksys3evt10OrderParam8tryAllocENS0_14OrderParamTypeEjRKN4sead14SafeStringBaseIcEE 0x0000007100db5598,ksys::evt::OrderParam::addParamActor,240,_ZN4ksys3evt10OrderParam13addParamActorEPNS_3act8BaseProcERN4sead14SafeStringBaseIcEE 0x0000007100db5688,ksys::evt::OrderParam::getIntByName,176,_ZN4ksys3evt10OrderParam12getIntByNameERKN4sead14SafeStringBaseIcEEPPj 0x0000007100db5738,ksys::evt::OrderParam::getStringByName,176,_ZN4ksys3evt10OrderParam15getStringByNameERKN4sead14SafeStringBaseIcEEPPS4_ diff --git a/src/KingSystem/Event/evtOrderParam.cpp b/src/KingSystem/Event/evtOrderParam.cpp index 2ae33304..5ff22d1d 100644 --- a/src/KingSystem/Event/evtOrderParam.cpp +++ b/src/KingSystem/Event/evtOrderParam.cpp @@ -215,44 +215,44 @@ OrderParamEntry* OrderParam::getFreeEntry() { } return nullptr; } -// This one does not match + OrderParamEntry* OrderParam::tryAlloc(OrderParamType type, u32 size, const sead::SafeString& name) { sead::FixedSafeString<0x100> error_message; error_message.format("[%s] tryAlloc_(%d, %d, %s) is failed.", "ksys::evt::OrderParam", static_cast(type), size, name.cstr()); - OrderParamEntry* entry = getFreeEntry(); // inlining here fixed the for loop + OrderParamEntry* entry = getFreeEntry(); if (!entry) return nullptr; auto* heap = mHeap; if (!heap) return nullptr; - std::nothrow_t nothrow; - entry->mName = - new (heap, nothrow) sead::FixedSafeString<0x20>(name); // scheduling mismatches here - // entry->mName = new_name; - // inlining here doesn't fix the mismatch + entry->mName = new (heap, std::nothrow_t()) sead::FixedSafeString<0x20>(name); switch (type) { case OrderParamType::INT: case OrderParamType::INT_2: - doAlloc(entry, new (heap, nothrow) s32(0)); + entry->mPointer = new (heap, std::nothrow_t()) s32(); + entry->mSize = sizeof(s32); break; case OrderParamType::STRING: - doAlloc(entry, - new (heap, nothrow) sead::FixedSafeString<0x40>); // scheduling mismatches here + entry->mPointer = new (heap, std::nothrow_t()) sead::FixedSafeString<0x40>; + entry->mSize = sizeof(sead::FixedSafeString<0x40>); break; case OrderParamType::BYTE: - doAlloc(entry, new (heap, nothrow) char(0)); + entry->mPointer = new (heap, std::nothrow_t()) bool(); + entry->mSize = sizeof(bool); break; case OrderParamType::ACTOR: - doAlloc(entry, new (heap, nothrow) ksys::act::BaseProcLink); + entry->mPointer = new (heap, std::nothrow_t()) ksys::act::BaseProcLink; + entry->mSize = sizeof(act::BaseProcLink); break; case OrderParamType::ARRAY: - doAlloc(entry, new (heap, nothrow) char[size], size); + entry->mPointer = new (heap, std::nothrow_t()) char[size]; + entry->mSize = size; break; default: break; diff --git a/src/KingSystem/Event/evtOrderParam.h b/src/KingSystem/Event/evtOrderParam.h index 52a7295c..f031e6db 100644 --- a/src/KingSystem/Event/evtOrderParam.h +++ b/src/KingSystem/Event/evtOrderParam.h @@ -78,13 +78,6 @@ private: return nullptr; return static_cast(entry->mPointer); } - template - void doAlloc(OrderParamEntry* e, T* ptr, u32 size = sizeof(T)) { - //*size_ptr = sizeof(T); - e->mPointer = ptr; - e->mSize = size; - // return sizeof(T); - } inline void clearEntry(OrderParamEntry* e) { e->mHash = 0; From 6699c1fb38549d66fea50ab3af1ca327ff32ca06 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A9o=20Lam?= Date: Sun, 7 Feb 2021 15:09:13 +0100 Subject: [PATCH 08/13] ksys/evt: Fix matching issue in OrderParam::initialize --- data/uking_functions.csv | 2 +- src/KingSystem/Event/evtOrderParam.cpp | 7 +++---- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/data/uking_functions.csv b/data/uking_functions.csv index ac83bfb2..8d94952c 100644 --- a/data/uking_functions.csv +++ b/data/uking_functions.csv @@ -75591,7 +75591,7 @@ 0x0000007100db4938,ksys::evt::OrderParam::dtorDelete,52,_ZN4ksys3evt10OrderParamD0Ev 0x0000007100db496c,ksys::evt::OrderParam::doAssign,1160,_ZN4ksys3evt10OrderParam8doAssignEPS1_ 0x0000007100db4df4,ksys::evt::OrderParam::assign,48,_ZN4ksys3evt10OrderParam6assignEPS1_ -0x0000007100db4e24,ksys::evt::OrderParam::initialize,332,_ZN4ksys3evt10OrderParam10initializeEi? +0x0000007100db4e24,ksys::evt::OrderParam::initialize,332,_ZN4ksys3evt10OrderParam10initializeEi 0x0000007100db4f70,ksys::evt::OrderParam::addParamInt,220,_ZN4ksys3evt10OrderParam11addParamIntEiRKN4sead14SafeStringBaseIcEE 0x0000007100db504c,ksys::evt::OrderParam::addParamString,412,_ZN4ksys3evt10OrderParam14addParamStringERKN4sead14SafeStringBaseIcEES6_ 0x0000007100db51e8,ksys::evt::OrderParam::tryAlloc_,944,_ZN4ksys3evt10OrderParam8tryAllocENS0_14OrderParamTypeEjRKN4sead14SafeStringBaseIcEE diff --git a/src/KingSystem/Event/evtOrderParam.cpp b/src/KingSystem/Event/evtOrderParam.cpp index 5ff22d1d..5d174cb4 100644 --- a/src/KingSystem/Event/evtOrderParam.cpp +++ b/src/KingSystem/Event/evtOrderParam.cpp @@ -28,10 +28,9 @@ bool OrderParam::initialize(s32 entry_count) { if (!mEntries.tryAllocBuffer(entry_count, mHeap)) return false; - for (s32 i = 0; i < entry_count; i++) { - clearEntry(&mEntries[i]); // no matter what I do, the compiler unrolls the first 2 - // iterations out of the loop - } + for (u32 i = 0; i < u32(entry_count); i++) + clearEntry(&mEntries[i]); + mEntryCount = 0; mInitialized = true; return true; From 136bd63cbc4a8136944d9b5f17ae3e9bac8bec72 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A9o=20Lam?= Date: Sun, 7 Feb 2021 16:17:13 +0100 Subject: [PATCH 09/13] ksys/evt: Rename members to match coding style --- src/KingSystem/Event/evtOrderParam.cpp | 108 ++++++++++++------------- src/KingSystem/Event/evtOrderParam.h | 43 +++++----- 2 files changed, 74 insertions(+), 77 deletions(-) diff --git a/src/KingSystem/Event/evtOrderParam.cpp b/src/KingSystem/Event/evtOrderParam.cpp index 5d174cb4..6561a91e 100644 --- a/src/KingSystem/Event/evtOrderParam.cpp +++ b/src/KingSystem/Event/evtOrderParam.cpp @@ -39,26 +39,26 @@ bool OrderParam::initialize(s32 entry_count) { void OrderParam::uninitialize() { for (s32 i = 0; i < mEntries.size(); i++) { auto* e = &mEntries[i]; - auto* name_ptr = e->mName; + auto* name_ptr = e->name; if (name_ptr) delete (sead::FixedSafeString<0x20>*)name_ptr; - auto* ptr = e->mPointer; + auto* ptr = e->data; if (ptr) { - switch (e->mType) { - case OrderParamType::STRING: + switch (e->type) { + case OrderParamType::String: delete (sead::FixedSafeString<0x40>*)ptr; break; - case OrderParamType::INT: - case OrderParamType::INT_2: + case OrderParamType::Int: + case OrderParamType::Float: delete (u32*)ptr; break; - case OrderParamType::BYTE: + case OrderParamType::Bool: delete (char*)ptr; break; - case OrderParamType::ACTOR: + case OrderParamType::Actor: delete (ksys::act::BaseProcLink*)ptr; break; - case OrderParamType::ARRAY: + case OrderParamType::Array: mHeap->free(ptr); break; default: @@ -97,37 +97,37 @@ bool OrderParam::doAssign(OrderParam* other) { for (s32 i = 0; i < mEntries.size(); i++) { auto* other_entry = other->getParam(i); if (other_entry) { - auto* other_ptr = other_entry->mPointer; - auto* other_name = other_entry->mName; + auto* other_ptr = other_entry->data; + auto* other_name = other_entry->name; ksys::act::BaseProcLink* link_ptr; ksys::act::BaseProc* actor_ptr; if (other_ptr && other_name) { - switch (other_entry->mType) { - case OrderParamType::INT: + switch (other_entry->type) { + case OrderParamType::Int: if (!addParamInt(*static_cast(other_ptr), *other_name)) return false; break; - case OrderParamType::INT_2: + case OrderParamType::Float: if (!addParamInt2(*static_cast(other_ptr), *other_name)) return false; break; - case OrderParamType::STRING: + case OrderParamType::String: if (!addParamString(*static_cast(other_ptr), *other_name)) return false; break; - case OrderParamType::BYTE: + case OrderParamType::Bool: if (!addParamByte(*static_cast(other_ptr), *other_name)) return false; break; - case OrderParamType::ACTOR: + case OrderParamType::Actor: link_ptr = static_cast(other_ptr); actor_ptr = sead::DynamicCast(link_ptr->getProc(nullptr, nullptr)); if (!addParamActor(actor_ptr, *other_name)) return false; break; - case OrderParamType::ARRAY: - if (!addParamArray(static_cast(other_ptr), other_entry->mSize, + case OrderParamType::Array: + if (!addParamArray(static_cast(other_ptr), other_entry->size, *other_name)) return false; break; @@ -141,7 +141,7 @@ bool OrderParam::doAssign(OrderParam* other) { } bool OrderParam::addParamInt(s32 val, const sead::SafeString& name) { - auto* entry_ptr = tryAllocParam(name, OrderParamType::INT); + auto* entry_ptr = tryAllocParam(name, OrderParamType::Int); if (!entry_ptr) return false; *entry_ptr = val; @@ -150,7 +150,7 @@ bool OrderParam::addParamInt(s32 val, const sead::SafeString& name) { } bool OrderParam::addParamInt2(s32 val, const sead::SafeString& name) { - auto* entry_ptr = tryAllocParam(name, OrderParamType::INT_2); + auto* entry_ptr = tryAllocParam(name, OrderParamType::Float); if (!entry_ptr) return false; *entry_ptr = val; @@ -158,7 +158,7 @@ bool OrderParam::addParamInt2(s32 val, const sead::SafeString& name) { return true; } bool OrderParam::addParamString(const sead::SafeString& val, const sead::SafeString& name) { - auto* entry_ptr = tryAllocParam(name, OrderParamType::STRING); + auto* entry_ptr = tryAllocParam(name, OrderParamType::String); if (!entry_ptr) return false; entry_ptr->copy(val); @@ -167,7 +167,7 @@ bool OrderParam::addParamString(const sead::SafeString& val, const sead::SafeStr } bool OrderParam::addParamByte(char val, const sead::SafeString& name) { - auto* entry_ptr = tryAllocParam(name, OrderParamType::BYTE); + auto* entry_ptr = tryAllocParam(name, OrderParamType::Bool); if (!entry_ptr) return false; *entry_ptr = val; @@ -176,7 +176,7 @@ bool OrderParam::addParamByte(char val, const sead::SafeString& name) { } bool OrderParam::addParamActor(ksys::act::BaseProc* actor, sead::SafeString& name) { - auto* entry_ptr = tryAllocParam(name, OrderParamType::ACTOR); + auto* entry_ptr = tryAllocParam(name, OrderParamType::Actor); if (!entry_ptr) return false; if (!entry_ptr->acquire(actor, false)) @@ -186,7 +186,7 @@ bool OrderParam::addParamActor(ksys::act::BaseProc* actor, sead::SafeString& nam } bool OrderParam::addParamArray(char* array, u32 size, sead::SafeString& name) { - auto* entry_ptr = tryAllocParam(name, OrderParamType::ARRAY, size); + auto* entry_ptr = tryAllocParam(name, OrderParamType::Array, size); if (!entry_ptr) return false; std::memcpy(entry_ptr, array, size); @@ -195,20 +195,20 @@ bool OrderParam::addParamArray(char* array, u32 size, sead::SafeString& name) { } bool OrderParam::getIntByName(const sead::SafeString& name, u32** out_ptr) { - return getPointerByName(name, out_ptr, OrderParamType::INT); + return getPointerByName(name, out_ptr, OrderParamType::Int); } bool OrderParam::getStringByName(const sead::SafeString& name, sead::SafeString** out_ptr) { - return getPointerByName(name, out_ptr, OrderParamType::STRING); + return getPointerByName(name, out_ptr, OrderParamType::String); } bool OrderParam::getArrayByName(const sead::SafeString& name, void** out_ptr, u32* out_size) { - return getPointerByName(name, out_ptr, OrderParamType::ARRAY, out_size); + return getPointerByName(name, out_ptr, OrderParamType::Array, out_size); } OrderParamEntry* OrderParam::getFreeEntry() { for (s32 i = 0; i < mEntries.size(); i++) { auto* entry = &mEntries[i]; - if (!entry->mPointer) { + if (!entry->data) { return entry; } } @@ -229,42 +229,42 @@ OrderParamEntry* OrderParam::tryAlloc(OrderParamType type, u32 size, const sead: if (!heap) return nullptr; - entry->mName = new (heap, std::nothrow_t()) sead::FixedSafeString<0x20>(name); + entry->name = new (heap, std::nothrow_t()) sead::FixedSafeString<0x20>(name); switch (type) { - case OrderParamType::INT: - case OrderParamType::INT_2: - entry->mPointer = new (heap, std::nothrow_t()) s32(); - entry->mSize = sizeof(s32); + case OrderParamType::Int: + case OrderParamType::Float: + entry->data = new (heap, std::nothrow_t()) s32(); + entry->size = sizeof(s32); break; - case OrderParamType::STRING: - entry->mPointer = new (heap, std::nothrow_t()) sead::FixedSafeString<0x40>; - entry->mSize = sizeof(sead::FixedSafeString<0x40>); + case OrderParamType::String: + entry->data = new (heap, std::nothrow_t()) sead::FixedSafeString<0x40>; + entry->size = sizeof(sead::FixedSafeString<0x40>); break; - case OrderParamType::BYTE: - entry->mPointer = new (heap, std::nothrow_t()) bool(); - entry->mSize = sizeof(bool); + case OrderParamType::Bool: + entry->data = new (heap, std::nothrow_t()) bool(); + entry->size = sizeof(bool); break; - case OrderParamType::ACTOR: - entry->mPointer = new (heap, std::nothrow_t()) ksys::act::BaseProcLink; - entry->mSize = sizeof(act::BaseProcLink); + case OrderParamType::Actor: + entry->data = new (heap, std::nothrow_t()) ksys::act::BaseProcLink; + entry->size = sizeof(act::BaseProcLink); break; - case OrderParamType::ARRAY: - entry->mPointer = new (heap, std::nothrow_t()) char[size]; - entry->mSize = size; + case OrderParamType::Array: + entry->data = new (heap, std::nothrow_t()) char[size]; + entry->size = size; break; default: break; } - auto* ptr = entry->mPointer; + auto* ptr = entry->data; if (ptr) { - entry->mHash = sead::HashCRC32::calcStringHash(*entry->mName); - entry->mType = type; + entry->hash = sead::HashCRC32::calcStringHash(*entry->name); + entry->type = type; } else { - if (entry->mName) - delete entry->mName; + if (entry->name) + delete entry->name; clearEntry(entry); entry = nullptr; } @@ -275,10 +275,10 @@ void* OrderParam::getPointerByName(const sead::SafeString& name, OrderParamType u32* out_size) const { const u32 hash = sead::HashCRC32::calcStringHash(name); for (s32 i = 0; i < mEntries.size(); i++) { - if (mEntries[i].mHash == hash && mEntries[i].mType == type) { + if (mEntries[i].hash == hash && mEntries[i].type == type) { if (out_size) - *out_size = mEntries[i].mSize; - return mEntries[i].mPointer; + *out_size = mEntries[i].size; + return mEntries[i].data; } } return nullptr; diff --git a/src/KingSystem/Event/evtOrderParam.h b/src/KingSystem/Event/evtOrderParam.h index f031e6db..cfacb699 100644 --- a/src/KingSystem/Event/evtOrderParam.h +++ b/src/KingSystem/Event/evtOrderParam.h @@ -9,28 +9,25 @@ namespace ksys::evt { enum class OrderParamType : u16 { - INVALID = 0, - INT = 1, - INT_2 = 2, - STRING = 3, - BYTE = 4, - ACTOR = 5, - ARRAY = 6 - + Invalid = 0, + Int = 1, + Float = 2, + String = 3, + Bool = 4, + Actor = 5, + Array = 6, }; struct OrderParamEntry { - u32 mHash; - // u32 _4; alignment gap - sead::SafeString* mName; - void* mPointer; //_10 - u32 mSize; //_18 - OrderParamType mType; - // u16 _1e; alignment gap + u32 hash; + sead::SafeString* name; + void* data; + u32 size; + OrderParamType type; }; class OrderParam { - OrderParam(sead::ExpHeap* mHeap); + OrderParam(sead::ExpHeap* heap); virtual ~OrderParam(); public: @@ -74,17 +71,17 @@ private: return nullptr; auto* entry = tryAlloc(type, size, name); - if (!entry || !(entry->mPointer)) + if (!entry || !(entry->data)) return nullptr; - return static_cast(entry->mPointer); + return static_cast(entry->data); } inline void clearEntry(OrderParamEntry* e) { - e->mHash = 0; - e->mSize = 0; - e->mType = OrderParamType::INVALID; - e->mName = nullptr; - e->mPointer = nullptr; + e->hash = 0; + e->size = 0; + e->type = OrderParamType::Invalid; + e->name = nullptr; + e->data = nullptr; } sead::ExpHeap* mHeap; From 9d81c0645f8e800d380a5352c5027824073f0d6c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A9o=20Lam?= Date: Sun, 7 Feb 2021 16:28:31 +0100 Subject: [PATCH 10/13] ksys/evt: Fix float/bool handling --- src/KingSystem/Event/evtOrderParam.cpp | 42 ++++++++++++++------------ src/KingSystem/Event/evtOrderParam.h | 4 +-- 2 files changed, 25 insertions(+), 21 deletions(-) diff --git a/src/KingSystem/Event/evtOrderParam.cpp b/src/KingSystem/Event/evtOrderParam.cpp index 6561a91e..30ff8211 100644 --- a/src/KingSystem/Event/evtOrderParam.cpp +++ b/src/KingSystem/Event/evtOrderParam.cpp @@ -38,25 +38,26 @@ bool OrderParam::initialize(s32 entry_count) { void OrderParam::uninitialize() { for (s32 i = 0; i < mEntries.size(); i++) { - auto* e = &mEntries[i]; - auto* name_ptr = e->name; - if (name_ptr) - delete (sead::FixedSafeString<0x20>*)name_ptr; - auto* ptr = e->data; + auto& entry = mEntries[i]; + if (entry.name) + delete (entry.name); + auto* ptr = entry.data; if (ptr) { - switch (e->type) { + switch (entry.type) { case OrderParamType::String: - delete (sead::FixedSafeString<0x40>*)ptr; + delete static_cast(ptr); break; case OrderParamType::Int: + delete static_cast(ptr); + break; case OrderParamType::Float: - delete (u32*)ptr; + delete static_cast(ptr); break; case OrderParamType::Bool: - delete (char*)ptr; + delete static_cast(ptr); break; case OrderParamType::Actor: - delete (ksys::act::BaseProcLink*)ptr; + delete static_cast(ptr); break; case OrderParamType::Array: mHeap->free(ptr); @@ -65,7 +66,7 @@ void OrderParam::uninitialize() { break; } } - clearEntry(e); + clearEntry(&entry); } mEntries.freeBuffer(); mEntryCount = 0; @@ -108,7 +109,7 @@ bool OrderParam::doAssign(OrderParam* other) { return false; break; case OrderParamType::Float: - if (!addParamInt2(*static_cast(other_ptr), *other_name)) + if (!addParamFloat(*static_cast(other_ptr), *other_name)) return false; break; case OrderParamType::String: @@ -116,7 +117,7 @@ bool OrderParam::doAssign(OrderParam* other) { return false; break; case OrderParamType::Bool: - if (!addParamByte(*static_cast(other_ptr), *other_name)) + if (!addParamBool(*static_cast(other_ptr), *other_name)) return false; break; case OrderParamType::Actor: @@ -149,8 +150,8 @@ bool OrderParam::addParamInt(s32 val, const sead::SafeString& name) { return true; } -bool OrderParam::addParamInt2(s32 val, const sead::SafeString& name) { - auto* entry_ptr = tryAllocParam(name, OrderParamType::Float); +bool OrderParam::addParamFloat(f32 val, const sead::SafeString& name) { + auto* entry_ptr = tryAllocParam(name, OrderParamType::Float); if (!entry_ptr) return false; *entry_ptr = val; @@ -166,8 +167,8 @@ bool OrderParam::addParamString(const sead::SafeString& val, const sead::SafeStr return true; } -bool OrderParam::addParamByte(char val, const sead::SafeString& name) { - auto* entry_ptr = tryAllocParam(name, OrderParamType::Bool); +bool OrderParam::addParamBool(bool val, const sead::SafeString& name) { + auto* entry_ptr = tryAllocParam(name, OrderParamType::Bool); if (!entry_ptr) return false; *entry_ptr = val; @@ -186,7 +187,7 @@ bool OrderParam::addParamActor(ksys::act::BaseProc* actor, sead::SafeString& nam } bool OrderParam::addParamArray(char* array, u32 size, sead::SafeString& name) { - auto* entry_ptr = tryAllocParam(name, OrderParamType::Array, size); + auto* entry_ptr = tryAllocParam(name, OrderParamType::Array, size); if (!entry_ptr) return false; std::memcpy(entry_ptr, array, size); @@ -233,10 +234,13 @@ OrderParamEntry* OrderParam::tryAlloc(OrderParamType type, u32 size, const sead: switch (type) { case OrderParamType::Int: - case OrderParamType::Float: entry->data = new (heap, std::nothrow_t()) s32(); entry->size = sizeof(s32); break; + case OrderParamType::Float: + entry->data = new (heap, std::nothrow_t()) f32(); + entry->size = sizeof(f32); + break; case OrderParamType::String: entry->data = new (heap, std::nothrow_t()) sead::FixedSafeString<0x40>; entry->size = sizeof(sead::FixedSafeString<0x40>); diff --git a/src/KingSystem/Event/evtOrderParam.h b/src/KingSystem/Event/evtOrderParam.h index cfacb699..7f3f8696 100644 --- a/src/KingSystem/Event/evtOrderParam.h +++ b/src/KingSystem/Event/evtOrderParam.h @@ -37,9 +37,9 @@ public: inline const OrderParamEntry* getParam(const s32 index) const; bool addParamInt(s32 val, const sead::SafeString& name); - bool addParamInt2(s32 val, const sead::SafeString& name); + bool addParamFloat(f32 val, const sead::SafeString& name); bool addParamString(const sead::SafeString& val, const sead::SafeString& name); - bool addParamByte(char val, const sead::SafeString& name); + bool addParamBool(bool val, const sead::SafeString& name); bool addParamActor(ksys::act::BaseProc* actor, sead::SafeString& name); bool addParamArray(char* array, u32 size, sead::SafeString& name); From db6d210a5389e3113504dbe870a6db3ea9a43fc4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A9o=20Lam?= Date: Sun, 7 Feb 2021 16:33:31 +0100 Subject: [PATCH 11/13] ksys/evt: Fix some function signatures --- data/uking_functions.csv | 6 +++--- src/KingSystem/Event/evtOrderParam.cpp | 21 +++++++++++---------- src/KingSystem/Event/evtOrderParam.h | 15 ++++++++------- 3 files changed, 22 insertions(+), 20 deletions(-) diff --git a/data/uking_functions.csv b/data/uking_functions.csv index 8d94952c..178a9b94 100644 --- a/data/uking_functions.csv +++ b/data/uking_functions.csv @@ -75585,12 +75585,12 @@ 0x0000007100db3ffc,evt::Event::doAssign,296, 0x0000007100db4124,evt::Event::assign,48, 0x0000007100db4154,sub_7100DB4154,1680, -0x0000007100db47e4,ksys::evt::OrderParam::ctor,36,_ZN4ksys3evt10OrderParamC1EPN4sead7ExpHeapE +0x0000007100db47e4,ksys::evt::OrderParam::ctor,36,_ZN4ksys3evt10OrderParamC1EPN4sead4HeapE 0x0000007100db4808,ksys::evt::OrderParam::dtor,20,_ZN4ksys3evt10OrderParamD1Ev 0x0000007100db481c,ksys::evt::OrderParam::uninitialize,284,_ZN4ksys3evt10OrderParam12uninitializeEv 0x0000007100db4938,ksys::evt::OrderParam::dtorDelete,52,_ZN4ksys3evt10OrderParamD0Ev -0x0000007100db496c,ksys::evt::OrderParam::doAssign,1160,_ZN4ksys3evt10OrderParam8doAssignEPS1_ -0x0000007100db4df4,ksys::evt::OrderParam::assign,48,_ZN4ksys3evt10OrderParam6assignEPS1_ +0x0000007100db496c,ksys::evt::OrderParam::doAssign,1160,_ZN4ksys3evt10OrderParam8doAssignERKS1_ +0x0000007100db4df4,ksys::evt::OrderParam::assign,48,_ZN4ksys3evt10OrderParamaSERKS1_ 0x0000007100db4e24,ksys::evt::OrderParam::initialize,332,_ZN4ksys3evt10OrderParam10initializeEi 0x0000007100db4f70,ksys::evt::OrderParam::addParamInt,220,_ZN4ksys3evt10OrderParam11addParamIntEiRKN4sead14SafeStringBaseIcEE 0x0000007100db504c,ksys::evt::OrderParam::addParamString,412,_ZN4ksys3evt10OrderParam14addParamStringERKN4sead14SafeStringBaseIcEES6_ diff --git a/src/KingSystem/Event/evtOrderParam.cpp b/src/KingSystem/Event/evtOrderParam.cpp index 30ff8211..1168fa2d 100644 --- a/src/KingSystem/Event/evtOrderParam.cpp +++ b/src/KingSystem/Event/evtOrderParam.cpp @@ -1,5 +1,4 @@ #include "KingSystem/Event/evtOrderParam.h" -#include #include #include #include @@ -8,7 +7,7 @@ namespace ksys::evt { -OrderParam::OrderParam(sead::ExpHeap* heap) { +OrderParam::OrderParam(sead::Heap* heap) { mHeap = heap; } @@ -77,26 +76,28 @@ const OrderParamEntry* OrderParam::getParam(const s32 index) const { sead::FixedSafeString<0x100> error_message; error_message.format("[%s] getParam(%d) is failed.", "ksys::evt::OrderParam", index); - if ((u32)std::max(0, mEntries.size()) > (u32)index) { + if (u32(std::max(0, mEntries.size())) > u32(index)) { return &mEntries[index]; } else { return nullptr; } } -OrderParam* OrderParam::assign(OrderParam* other) { - if (this != other) { + +OrderParam& OrderParam::operator=(const OrderParam& other) { + if (this != &other) { doAssign(other); } - return this; + return *this; } -bool OrderParam::doAssign(OrderParam* other) { - if (this == other) +bool OrderParam::doAssign(const OrderParam& other) { + if (this == &other) return true; - if (!initialize(std::max(0, other->mEntries.size()))) + + if (!initialize(std::max(0, other.mEntries.size()))) return false; for (s32 i = 0; i < mEntries.size(); i++) { - auto* other_entry = other->getParam(i); + auto* other_entry = other.getParam(i); if (other_entry) { auto* other_ptr = other_entry->data; auto* other_name = other_entry->name; diff --git a/src/KingSystem/Event/evtOrderParam.h b/src/KingSystem/Event/evtOrderParam.h index 7f3f8696..5498a307 100644 --- a/src/KingSystem/Event/evtOrderParam.h +++ b/src/KingSystem/Event/evtOrderParam.h @@ -27,15 +27,15 @@ struct OrderParamEntry { }; class OrderParam { - OrderParam(sead::ExpHeap* heap); - virtual ~OrderParam(); - public: + explicit OrderParam(sead::Heap* heap); + OrderParam(const OrderParam& other) { *this = other; } + virtual ~OrderParam(); + OrderParam& operator=(const OrderParam& other); bool initialize(s32 entry_count); void uninitialize(); - OrderParam* assign(OrderParam* other); - inline const OrderParamEntry* getParam(const s32 index) const; + const OrderParamEntry* getParam(s32 index) const; bool addParamInt(s32 val, const sead::SafeString& name); bool addParamFloat(f32 val, const sead::SafeString& name); bool addParamString(const sead::SafeString& val, const sead::SafeString& name); @@ -49,7 +49,8 @@ public: bool getArrayByName(const sead::SafeString& name, void** out_ptr, u32* out_size); private: - bool doAssign(OrderParam* other); + bool doAssign(const OrderParam& other); + OrderParamEntry* getFreeEntry(); void* getPointerByName(const sead::SafeString& name, OrderParamType type, u32* out_size = nullptr) const; @@ -84,7 +85,7 @@ private: e->data = nullptr; } - sead::ExpHeap* mHeap; + sead::Heap* mHeap; sead::Buffer mEntries; u32 mEntryCount = 0; bool mInitialized = false; From 5b90a9b40f0c81fbc39e59b1bcb6fb84641be034 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A9o=20Lam?= Date: Sun, 7 Feb 2021 16:37:46 +0100 Subject: [PATCH 12/13] ksys/evt: More coding style tweaks --- src/KingSystem/Event/evtOrderParam.cpp | 18 ++++++++++-------- src/KingSystem/Event/evtOrderParam.h | 18 +++++++++--------- 2 files changed, 19 insertions(+), 17 deletions(-) diff --git a/src/KingSystem/Event/evtOrderParam.cpp b/src/KingSystem/Event/evtOrderParam.cpp index 1168fa2d..06915c58 100644 --- a/src/KingSystem/Event/evtOrderParam.cpp +++ b/src/KingSystem/Event/evtOrderParam.cpp @@ -28,7 +28,7 @@ bool OrderParam::initialize(s32 entry_count) { return false; for (u32 i = 0; i < u32(entry_count); i++) - clearEntry(&mEntries[i]); + mEntries[i].clear(); mEntryCount = 0; mInitialized = true; @@ -65,7 +65,7 @@ void OrderParam::uninitialize() { break; } } - clearEntry(&entry); + entry.clear(); } mEntries.freeBuffer(); mEntryCount = 0; @@ -159,6 +159,7 @@ bool OrderParam::addParamFloat(f32 val, const sead::SafeString& name) { ++mEntryCount; return true; } + bool OrderParam::addParamString(const sead::SafeString& val, const sead::SafeString& name) { auto* entry_ptr = tryAllocParam(name, OrderParamType::String); if (!entry_ptr) @@ -207,6 +208,7 @@ bool OrderParam::getStringByName(const sead::SafeString& name, sead::SafeString* bool OrderParam::getArrayByName(const sead::SafeString& name, void** out_ptr, u32* out_size) { return getPointerByName(name, out_ptr, OrderParamType::Array, out_size); } + OrderParamEntry* OrderParam::getFreeEntry() { for (s32 i = 0; i < mEntries.size(); i++) { auto* entry = &mEntries[i]; @@ -267,13 +269,13 @@ OrderParamEntry* OrderParam::tryAlloc(OrderParamType type, u32 size, const sead: if (ptr) { entry->hash = sead::HashCRC32::calcStringHash(*entry->name); entry->type = type; - } else { - if (entry->name) - delete entry->name; - clearEntry(entry); - entry = nullptr; + return entry; } - return entry; + + if (entry->name) + delete entry->name; + entry->clear(); + return nullptr; } void* OrderParam::getPointerByName(const sead::SafeString& name, OrderParamType type, diff --git a/src/KingSystem/Event/evtOrderParam.h b/src/KingSystem/Event/evtOrderParam.h index 5498a307..95f2a5fb 100644 --- a/src/KingSystem/Event/evtOrderParam.h +++ b/src/KingSystem/Event/evtOrderParam.h @@ -19,6 +19,14 @@ enum class OrderParamType : u16 { }; struct OrderParamEntry { + void clear() { + hash = 0; + size = 0; + type = OrderParamType::Invalid; + name = nullptr; + data = nullptr; + } + u32 hash; sead::SafeString* name; void* data; @@ -72,19 +80,11 @@ private: return nullptr; auto* entry = tryAlloc(type, size, name); - if (!entry || !(entry->data)) + if (!entry || !entry->data) return nullptr; return static_cast(entry->data); } - inline void clearEntry(OrderParamEntry* e) { - e->hash = 0; - e->size = 0; - e->type = OrderParamType::Invalid; - e->name = nullptr; - e->data = nullptr; - } - sead::Heap* mHeap; sead::Buffer mEntries; u32 mEntryCount = 0; From 4ad57a05d4d8904de18c525b2576f8c9dbda85c6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A9o=20Lam?= Date: Sun, 7 Feb 2021 16:39:19 +0100 Subject: [PATCH 13/13] ksys/evt: Mark member functions as const when applicable --- data/uking_functions.csv | 6 +++--- src/KingSystem/Event/evtOrderParam.cpp | 6 +++--- src/KingSystem/Event/evtOrderParam.h | 6 +++--- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/data/uking_functions.csv b/data/uking_functions.csv index 178a9b94..15cda80c 100644 --- a/data/uking_functions.csv +++ b/data/uking_functions.csv @@ -75596,9 +75596,9 @@ 0x0000007100db504c,ksys::evt::OrderParam::addParamString,412,_ZN4ksys3evt10OrderParam14addParamStringERKN4sead14SafeStringBaseIcEES6_ 0x0000007100db51e8,ksys::evt::OrderParam::tryAlloc_,944,_ZN4ksys3evt10OrderParam8tryAllocENS0_14OrderParamTypeEjRKN4sead14SafeStringBaseIcEE 0x0000007100db5598,ksys::evt::OrderParam::addParamActor,240,_ZN4ksys3evt10OrderParam13addParamActorEPNS_3act8BaseProcERN4sead14SafeStringBaseIcEE -0x0000007100db5688,ksys::evt::OrderParam::getIntByName,176,_ZN4ksys3evt10OrderParam12getIntByNameERKN4sead14SafeStringBaseIcEEPPj -0x0000007100db5738,ksys::evt::OrderParam::getStringByName,176,_ZN4ksys3evt10OrderParam15getStringByNameERKN4sead14SafeStringBaseIcEEPPS4_ -0x0000007100db57e8,ksys::evt::OrderParam::getArrayByName,208,_ZN4ksys3evt10OrderParam14getArrayByNameERKN4sead14SafeStringBaseIcEEPPvPj +0x0000007100db5688,ksys::evt::OrderParam::getIntByName,176,_ZNK4ksys3evt10OrderParam12getIntByNameERKN4sead14SafeStringBaseIcEEPPj +0x0000007100db5738,ksys::evt::OrderParam::getStringByName,176,_ZNK4ksys3evt10OrderParam15getStringByNameERKN4sead14SafeStringBaseIcEEPPS4_ +0x0000007100db57e8,ksys::evt::OrderParam::getArrayByName,208,_ZNK4ksys3evt10OrderParam14getArrayByNameERKN4sead14SafeStringBaseIcEEPPvPj 0x0000007100db58b8,evt::EventFlowBase::ctor,2140, 0x0000007100db6114,_ZN4sead9SafeArrayINS_15FixedSafeStringILi64EEELi8EEC2Ev,360, 0x0000007100db627c,evt::EventFlowBase::getBaseProcLink,12, diff --git a/src/KingSystem/Event/evtOrderParam.cpp b/src/KingSystem/Event/evtOrderParam.cpp index 06915c58..0504ed5e 100644 --- a/src/KingSystem/Event/evtOrderParam.cpp +++ b/src/KingSystem/Event/evtOrderParam.cpp @@ -197,15 +197,15 @@ bool OrderParam::addParamArray(char* array, u32 size, sead::SafeString& name) { return true; } -bool OrderParam::getIntByName(const sead::SafeString& name, u32** out_ptr) { +bool OrderParam::getIntByName(const sead::SafeString& name, u32** out_ptr) const { return getPointerByName(name, out_ptr, OrderParamType::Int); } -bool OrderParam::getStringByName(const sead::SafeString& name, sead::SafeString** out_ptr) { +bool OrderParam::getStringByName(const sead::SafeString& name, sead::SafeString** out_ptr) const { return getPointerByName(name, out_ptr, OrderParamType::String); } -bool OrderParam::getArrayByName(const sead::SafeString& name, void** out_ptr, u32* out_size) { +bool OrderParam::getArrayByName(const sead::SafeString& name, void** out_ptr, u32* out_size) const { return getPointerByName(name, out_ptr, OrderParamType::Array, out_size); } diff --git a/src/KingSystem/Event/evtOrderParam.h b/src/KingSystem/Event/evtOrderParam.h index 95f2a5fb..d53c02fa 100644 --- a/src/KingSystem/Event/evtOrderParam.h +++ b/src/KingSystem/Event/evtOrderParam.h @@ -52,9 +52,9 @@ public: bool addParamArray(char* array, u32 size, sead::SafeString& name); OrderParamEntry* tryAlloc(OrderParamType type, u32 size, const sead::SafeString& name); - bool getIntByName(const sead::SafeString& name, u32** out_ptr); - bool getStringByName(const sead::SafeString& name, sead::SafeString** out_ptr); - bool getArrayByName(const sead::SafeString& name, void** out_ptr, u32* out_size); + bool getIntByName(const sead::SafeString& name, u32** out_ptr) const; + bool getStringByName(const sead::SafeString& name, sead::SafeString** out_ptr) const; + bool getArrayByName(const sead::SafeString& name, void** out_ptr, u32* out_size) const; private: bool doAssign(const OrderParam& other);