cafe/nn_ec: Add more functions.

src/libdecaf/src/cafe/libraries/nn_ec/nn_ec.cpp

@@ -17,8 +17,10 @@ Library::registerSymbols()
 
    registerCatalogSymbols();
    registerItemListSymbols();
+   registerLibSymbols();
    registerMemoryManagerSymbols();
    registerMoneySymbols();
+   registerQuerySymbols();
    registerRootObjectSymbols();
    registerShoppingCatalogSymbols();
 }

src/libdecaf/src/cafe/libraries/nn_ec/nn_ec.h

@@ -17,8 +17,10 @@ protected:
 
    void registerCatalogSymbols();
    void registerItemListSymbols();
+   void registerLibSymbols();
    void registerMemoryManagerSymbols();
    void registerMoneySymbols();
+   void registerQuerySymbols();
    void registerRootObjectSymbols();
    void registerShoppingCatalogSymbols();
 

src/libdecaf/src/cafe/libraries/nn_ec/nn_ec_lib.cpp

@@ -0,0 +1,49 @@
+#include "cafe/libraries/nn_ec/nn_ec.h"
+#include "cafe/libraries/nn_ec/nn_ec_lib.h"
+#include "cafe/libraries/nn_ec/nn_ec_memorymanager.h"
+#include "cafe/libraries/nn_ec/nn_ec_result.h"
+
+#include "cafe/libraries/cafe_hle_stub.h"
+
+namespace cafe::nn_ec
+{
+
+nn::Result
+Initialize(uint32_t unk0)
+{
+   decaf_warn_stub();
+   return nn::ResultSuccess;
+}
+
+nn::Result
+Finalize()
+{
+   decaf_warn_stub();
+   return nn::ResultSuccess;
+}
+
+nn::Result
+SetAllocator(MemoryManager::AllocFn allocFn,
+             MemoryManager::FreeFn freeFn)
+{
+   auto test = nn::Result(0xC1603C80);
+   if (!allocFn || !freeFn) {
+      return ResultInvalidArgument;
+   }
+
+   internal::MemoryManager_SetAllocator(allocFn, freeFn);
+   return nn::ResultSuccess;
+}
+
+void
+Library::registerLibSymbols()
+{
+   RegisterFunctionExportName("Initialize__Q2_2nn2ecFUi",
+                              Initialize);
+   RegisterFunctionExportName("Finalize__Q2_2nn2ecFv",
+                              Finalize);
+   RegisterFunctionExportName("SetAllocator__Q2_2nn2ecFPFUii_PvPFPv_v",
+                              SetAllocator);
+}
+
+} // namespace cafe::nn_ec

src/libdecaf/src/cafe/libraries/nn_ec/nn_ec_lib.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "nn_ec_memorymanager.h"
+
+#include "nn/nn_result.h"
+#include <libcpu/be2_struct.h>
+
+namespace cafe::nn_ec
+{
+
+nn::Result
+Initialize(uint32_t unk0);
+
+nn::Result
+Finalize();
+
+nn::Result
+SetAllocator(MemoryManager::AllocFn allocate, MemoryManager::FreeFn free);
+
+} // namespace cafe::nn_ec

src/libdecaf/src/cafe/libraries/nn_ec/nn_ec_memorymanager.cpp

@@ -33,8 +33,8 @@ MemoryManager_GetSingleton()
 virt_ptr<MemoryManager>
 MemoryManager_Constructor(virt_ptr<MemoryManager> self)
 {
-   self->_allocFn = sDefaultAllocFn;
-   self->_freeFn = sDefaultFreeFn;
+   self->allocFn = sDefaultAllocFn;
+   self->freeFn = sDefaultFreeFn;
    return self;
 }
 
@@ -43,21 +43,32 @@ MemoryManager_Allocate(virt_ptr<MemoryManager> self,
                        uint32_t size,
                        uint32_t align)
 {
-   std::unique_lock<nn::os::CriticalSection> lock { self->_mutex };
-   return cafe::invoke(cpu::this_core::state(), self->_allocFn, size, align);
+   std::unique_lock<nn::os::CriticalSection> lock { self->mutex };
+   return cafe::invoke(cpu::this_core::state(), self->allocFn, size, align);
 }
 
 void
 MemoryManager_Free(virt_ptr<MemoryManager> self,
                    virt_ptr<void> ptr)
 {
-   std::unique_lock<nn::os::CriticalSection> lock { self->_mutex };
-   return cafe::invoke(cpu::this_core::state(), self->_freeFn, ptr);
+   std::unique_lock<nn::os::CriticalSection> lock { self->mutex };
+   return cafe::invoke(cpu::this_core::state(), self->freeFn, ptr);
 }
 
 namespace internal
 {
 
+void
+MemoryManager_SetAllocator(MemoryManager::AllocFn allocFn,
+                           MemoryManager::FreeFn freeFn)
+{
+   auto memoryManager = MemoryManager_GetSingleton();
+
+   std::unique_lock<nn::os::CriticalSection> lock { memoryManager->mutex };
+   memoryManager->allocFn = allocFn;
+   memoryManager->freeFn = freeFn;
+}
+
 static virt_ptr<void> defaultAllocFn(uint32_t size, uint32_t align)
 {
    return coreinit::MEMAllocFromDefaultHeapEx(size, align);

src/libdecaf/src/cafe/libraries/nn_ec/nn_ec_memorymanager.h

@@ -11,14 +11,14 @@ struct MemoryManager
    using AllocFn = virt_func_ptr<virt_ptr<void>(uint32_t size, uint32_t align)>;
    using FreeFn = virt_func_ptr<void(virt_ptr<void> ptr)>;
 
-   be2_struct<nn::os::CriticalSection> _mutex;
-   be2_val<AllocFn> _allocFn;
-   be2_val<FreeFn> _freeFn;
+   be2_struct<nn::os::CriticalSection> mutex;
+   be2_val<AllocFn> allocFn;
+   be2_val<FreeFn> freeFn;
    UNKNOWN(0x48 - 0x34);
 };
-CHECK_OFFSET(MemoryManager, 0x00, _mutex);
-CHECK_OFFSET(MemoryManager, 0x2C, _allocFn);
-CHECK_OFFSET(MemoryManager, 0x30, _freeFn);
+CHECK_OFFSET(MemoryManager, 0x00, mutex);
+CHECK_OFFSET(MemoryManager, 0x2C, allocFn);
+CHECK_OFFSET(MemoryManager, 0x30, freeFn);
 CHECK_SIZE(MemoryManager, 0x48);
 
 virt_ptr<MemoryManager>
@@ -36,4 +36,13 @@ void
 MemoryManager_Free(virt_ptr<MemoryManager> self,
                    virt_ptr<void> ptr);
 
+namespace internal
+{
+
+void
+MemoryManager_SetAllocator(MemoryManager::AllocFn allocFn,
+                           MemoryManager::FreeFn freeFn);
+
+} // internal
+
 } // namespace cafe::nn_ec

src/libdecaf/src/cafe/libraries/nn_ec/nn_ec_query.cpp

@@ -0,0 +1,56 @@
+#include "cafe/libraries/nn_ec/nn_ec.h"
+#include "cafe/libraries/nn_ec/nn_ec_query.h"
+#include "cafe/libraries/nn_ec/nn_ec_rootobject.h"
+
+#include "cafe/libraries/cafe_hle_stub.h"
+
+namespace cafe::nn_ec
+{
+
+virt_ptr<Query>
+Query_Constructor(virt_ptr<Query> self)
+{
+   if (!self) {
+      self = virt_cast<Query *>(RootObject_New(sizeof(Query)));
+      if (!self) {
+         return nullptr;
+      }
+   }
+
+   self->impl = nullptr;
+   return self;
+}
+
+void
+Query_Destructor(virt_ptr<Query> self,
+                 ghs::DestructorFlags flags)
+{
+   Query_Clear(self);
+
+   if (flags & ghs::DestructorFlags::FreeMemory) {
+      RootObject_Free(self);
+   }
+}
+
+void
+Query_Clear(virt_ptr<Query> self)
+{
+   if (self->impl) {
+      decaf_warn_stub();
+   }
+
+   self->impl = nullptr;
+}
+
+void
+Library::registerQuerySymbols()
+{
+   RegisterFunctionExportName("__ct__Q3_2nn2ec5QueryFv",
+                              Query_Constructor);
+   RegisterFunctionExportName("__dt__Q3_2nn2ec5QueryFv",
+                              Query_Destructor);
+   RegisterFunctionExportName("Clear__Q3_2nn2ec5QueryFv",
+                              Query_Clear);
+}
+
+} // namespace cafe::nn_ec

src/libdecaf/src/cafe/libraries/nn_ec/nn_ec_query.h

@@ -0,0 +1,25 @@
+#pragma once
+#include "cafe/libraries/nn_ec/nn_ec_rootobject.h"
+#include "cafe/libraries/nn_ec/nn_ec_noncopyable.h"
+
+#include <libcpu/be2_struct.h>
+
+namespace cafe::nn_ec
+{
+
+struct Query : RootObject
+{
+   be2_virt_ptr<void> impl;
+};
+
+virt_ptr<Query>
+Query_Constructor(virt_ptr<Query> self);
+
+void
+Query_Destructor(virt_ptr<Query> self,
+                 ghs::DestructorFlags flags);
+
+void
+Query_Clear(virt_ptr<Query> self);
+
+} // namespace cafe::nn_ec

src/libdecaf/src/cafe/libraries/nn_ec/nn_ec_result.h

@@ -0,0 +1,11 @@
+#pragma once
+#include "nn/nn_result.h"
+
+namespace cafe::nn_ec
+{
+
+static constexpr nn::Result ResultInvalidArgument {
+   nn::Result::MODULE_NN_EC, nn::Result::LEVEL_USAGE, 0x3C80
+};
+
+} // namespace cafe::nn_ec