Emulator-Archive/psOff_public
1
0
Fork 0
mirror of https://github.com/SysRay/psOff_public.git synced 2024-11-26 16:10:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

+ logging

Browse Source
This commit is contained in:
Martin Baliet 2024-03-01 15:09:01 +01:00
parent bc58a8c157
commit 3e99d2c9aa
52 changed files with 741 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.vscode/settings.json vendored
View File

@ -9,5 +9,5 @@
"asciidoc.preview.useEditorStyle": false,
"asciidoc.use_asciidoctorpdf": true,
"editor.tabSize": 2,
"git.ignoredRepositories": ["third_party/boost", "third_party/optick"]
"git.ignoredRepositories": ["third_party/boost", "third_party/optick", "third_party/glfw"]
}

6
CMakeLists.txt
View File

@ -33,6 +33,7 @@ message("Vulkan Path: ${VulkanPath}")
include_directories(BEFORE
${CMAKE_INSTALL_PREFIX}/development/include
${PRJ_SRC_DIR}/modules_include
${PRJ_SRC_DIR}/tools/logging
${PRJ_SRC_DIR}
${CMAKE_BINARY_DIR}/third_party/install/include
)
@ -43,9 +44,11 @@ link_directories(BEFORE
${CMAKE_BINARY_DIR}/core
)
add_subdirectory(tools/logging) # include befire link_libraries
link_libraries(
psOff_utility
logging
logging.lib
)
add_definitions("-D__APICALL_IMPORT")
@ -57,6 +60,7 @@ include("third_party/third_party.cmake")
add_subdirectory(modules)
add_subdirectory(core)
# #- Projects
# # Install

1
core/CMakeLists.txt
View File

@ -14,6 +14,7 @@ add_library(core SHARED
$<TARGET_OBJECTS:videoout>
)
add_dependencies(core logging)
target_link_libraries(core PRIVATE
libboost_thread
libboost_chrono

3
core/kernel/eventflag.cpp
View File

@ -2,12 +2,13 @@
#include "eventflag.h"
#undef __APICALL_EXTERN
#include "logging.h"
#include "modules_include/common.h"
#include <boost/thread/condition.hpp>
#include <logging.h>
#include <memory>
LOG_DEFINE_MODULE(KernelEventFlag);
namespace Kernel::EventFlag {

2
core/kernel/eventqueue.cpp
View File

@ -2,6 +2,7 @@
#include "eventqueue.h"
#undef __APICALL_EXTERN
#include "logging.h"
#include "modules_include/common.h"
#include <algorithm>
@ -10,7 +11,6 @@
#include <boost/thread/mutex.hpp>
#include <chrono>
#include <list>
#include <logging.h>
#include <memory>
#include <mutex>
#include <string>

2
core/videoout/videoout.cpp
View File

@ -3,6 +3,7 @@
#undef __APICALL_EXTERN
#include "core/kernel/eventqueue.h"
#include "logging.h"
#include "modules/libSceVideoOut/codes.h"
#include "modules/libSceVideoOut/types.h"
#include "modules_include/common.h"
@ -20,7 +21,6 @@
#include <graphics.h>
#include <initParams.h>
#include <list>
#include <logging.h>
#include <memory>
#include <mutex>
#include <optick.h>

4
core/videoout/vulkan/vulkanSetup.cpp
View File

@ -1,10 +1,12 @@
#include "vulkanSetup.h"
#include "logging.h"
#include <format>
#include <logging.h>
#include <utility/utility.h>
#include <vulkan/vk_enum_string_helper.h>
#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>

12
modules/libSceAjm/entry.cpp
View File

@ -1,8 +1,7 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceAjm);
namespace {} // namespace
@ -14,33 +13,42 @@ EXPORT const char* MODULE_NAME = "libSceAjm";
EXPORT SYSV_ABI int32_t sceAjmInitialize(int64_t iReserved, SceAjmContextId* const pContext) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAjmFinalize(const SceAjmContextId uiContext) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAjmMemoryRegister(const SceAjmContextId uiContext, void* const pRegion, const size_t szNumPages) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAjmMemoryUnregister(const SceAjmContextId uiContext, void* const pRegion) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAjmModuleRegister(const SceAjmContextId uiContext, const SceAjmCodecType uiCodec, int64_t iReserved) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAjmModuleUnregister(const SceAjmContextId uiContext, const SceAjmCodecType uiCodec) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAjmInstanceCreate(const SceAjmContextId uiContext, const SceAjmCodecType uiCodec, const uint64_t uiFlags,
SceAjmInstanceId* const pInstance) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAjmInstanceExtend(const SceAjmContextId uiContext, const SceAjmCodecType uiCodec, const uint64_t uiFlags,
SceAjmInstanceId uiInstance) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAjmInstanceSwitch(const SceAjmContextId uiContext, const SceAjmCodecType uiCodec, const uint64_t uiFlags,
const SceAjmInstanceId uiInstance) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAjmInstanceDestroy(const SceAjmContextId uiContext, const SceAjmInstanceId uiInstance) {
return Ok;
}

2
modules/libSceAppContent/entry.cpp
View File

@ -1,10 +1,10 @@
#include "../libSceNpManager/types.h"
#include "common.h"
#include "logging.h"
#include "types.h"
#include <fileManager.h>
#include <filesystem>
#include <logging.h>
#include <optional>
#include <systemContent.h>

7
modules/libSceAudioIn/entry.cpp
View File

@ -1,8 +1,7 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceAudioIn);
namespace {} // namespace
@ -14,15 +13,19 @@ EXPORT const char* MODULE_NAME = "libSceAudioIn";
EXPORT SYSV_ABI int32_t sceAudioInOpen(int32_t userId, int32_t type, int32_t index, uint32_t len, uint32_t freq, uint32_t param) {
return Err::PORT_FULL;
}
EXPORT SYSV_ABI int32_t sceAudioInClose(int32_t handle) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAudioInInput(int32_t handle, void* dest) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAudioInGetSilentState(int32_t handle) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAudioInHqOpen(int32_t userId, int32_t type, int32_t index, uint32_t timeLen, uint32_t freq, uint32_t param) {
return Ok;
}

2
modules/libSceAudioOut/entry.cpp
View File

@ -1,10 +1,10 @@
#include "common.h"
#include "logging.h"
#include "portaudio.h"
#include "types.h"
#include <array>
#include <chrono>
#include <logging.h>
#include <mutex>
LOG_DEFINE_MODULE(libSceAudioOut);

4
modules/libSceAvPlayer/avplayer.cpp
View File

@ -1,10 +1,10 @@
#include "avplayer.h"
#include "logging.h"
#include "typesEx.h"
#include <fileManager.h>
#include <gpuMemoryManagerExports.h>
#include <logging.h>
extern "C" {
#include <libavcodec/avcodec.h>
@ -93,6 +93,7 @@ class Avplayer: public IAvplayer {
std::unique_ptr<std::thread> m_decodeThread;
std::condition_variable m_condDecode; // Notify Decoding Thread
// - Decode Thread
struct DataBase {
@ -144,6 +145,7 @@ class Avplayer: public IAvplayer {
};
bool setFile(const char* filename) final;
void setLoop(bool isLoop) final {
std::unique_lock const lock(m_mutex_int);
m_isLoop = isLoop;

26
modules/libSceAvPlayer/entry.cpp
View File

@ -1,8 +1,7 @@
#include "avplayer.h"
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceAvPlayer);
namespace {} // namespace
@ -15,77 +14,100 @@ EXPORT SYSV_ABI SceAvPlayerHandle sceAvPlayerInit(SceAvPlayerInitData* pInit) {
auto inst = createAvPlayer(pInit->memoryReplacement);
return inst.release();
}
EXPORT SYSV_ABI int32_t sceAvPlayerPostInit(IAvplayer* avPlayer, SceAvPlayerPostInitData* pPostInit) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAvPlayerClose(IAvplayer* avPlayer) {
delete avPlayer;
return Ok;
}
EXPORT SYSV_ABI int32_t sceAvPlayerAddSource(IAvplayer* avPlayer, const char* filename) {
if (avPlayer->setFile(filename)) return Ok;
return Err::INVALID_PARAMS;
}
EXPORT SYSV_ABI int32_t sceAvPlayerStreamCount(IAvplayer* avPlayer) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAvPlayerGetStreamInfo(IAvplayer* avPlayer, uint32_t argStreamID, SceAvPlayerStreamInfo* argInfo) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAvPlayerEnableStream(IAvplayer* avPlayer, uint32_t argStreamID) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAvPlayerDisableStream(IAvplayer* avPlayer, uint32_t argStreamID) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAvPlayerChangeStream(IAvplayer* avPlayer, uint32_t argOldStreamID, uint32_t argNewStreamID) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAvPlayerStart(IAvplayer* avPlayer) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAvPlayerStop(IAvplayer* avPlayer) {
avPlayer->stop();
return Ok;
}
EXPORT SYSV_ABI int32_t sceAvPlayerPause(IAvplayer* avPlayer) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAvPlayerResume(IAvplayer* avPlayer) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAvPlayerSetLooping(IAvplayer* avPlayer, bool loopFlag) {
avPlayer->setLoop(loopFlag);
return Ok;
}
EXPORT SYSV_ABI bool sceAvPlayerIsActive(IAvplayer* avPlayer) {
if (avPlayer != nullptr) return avPlayer->isPlaying();
return false;
}
EXPORT SYSV_ABI bool sceAvPlayerGetAudioData(IAvplayer* avPlayer, SceAvPlayerFrameInfo* audioInfo) {
return avPlayer->getAudioData(audioInfo);
}
EXPORT SYSV_ABI bool sceAvPlayerGetVideoData(IAvplayer* avPlayer, SceAvPlayerFrameInfo* videoInfo) {
return avPlayer->getVideoData(videoInfo, false);
}
EXPORT SYSV_ABI uint64_t sceAvPlayerCurrentTime(IAvplayer* avPlayer) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAvPlayerJumpToTime(IAvplayer* avPlayer, uint64_t argJumpTimeMsec) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAvPlayerSetTrickSpeed(IAvplayer* avPlayer, int32_t argTrickSpeed) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAvPlayerSetAvSyncMode(IAvplayer* avPlayer, SceAvPlayerAvSyncMode argSyncMode) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAvPlayerSetLogCallback(SceAvPlayerLogCallback logCb, void* userData) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAvPlayerPrintf(const char* format, ...) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceAvPlayerVprintf(const char* str, va_list args) {
LOG_USE_MODULE(libSceAvPlayer);
std::string format(str);

5
modules/libSceAvPlayer/entryEx.cpp
View File

@ -1,9 +1,8 @@
#include "avplayer.h"
#include "common.h"
#include "logging.h"
#include "typesEx.h"
#include <logging.h>
namespace {} // namespace
extern "C" {
@ -13,9 +12,11 @@ EXPORT SYSV_ABI int32_t sceAvPlayerInitEx(const SceAvPlayerInitDataEx* initDataE
return Ok;
}
EXPORT SYSV_ABI bool sceAvPlayerGetVideoDataEx(IAvplayer* avPlayer, SceAvPlayerFrameInfoEx* videoInfo) {
return avPlayer->getVideoData(videoInfo, true);
}
EXPORT SYSV_ABI int32_t sceAvPlayerAddSourceEx(IAvplayer* avPlayer, SceAvPlayerUriType uriType, SceAvPlayerSourceDetails* sourceDetails) {
if (avPlayer->setFile(sourceDetails->uri.name)) return Ok;
return Err::INVALID_PARAMS;

3
modules/libSceCommonDialog/entry.cpp
View File

@ -1,7 +1,6 @@
#include "common.h"
#include "errorcodes.h"
#include <logging.h>
#include "logging.h"
LOG_DEFINE_MODULE(libSceCommonDialog);

15
modules/libSceCoredump/entry.cpp
View File

@ -1,8 +1,8 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <boost/thread.hpp>
#include <logging.h>
#include <memory>
#include <utility/utility.h>
LOG_DEFINE_MODULE(libSceCoredump);
@ -43,6 +43,7 @@ EXPORT SYSV_ABI int32_t sceCoredumpRegisterCoredumpHandler(SceCoredumpHandler ha
return Ok;
}
EXPORT SYSV_ABI int32_t sceCoredumpUnregisterCoredumpHandler(void) {
LOG_USE_MODULE(libSceCoredump);
LOG_ERR(L"todo %S", __FUNCTION__);
@ -52,59 +53,71 @@ EXPORT SYSV_ABI int32_t sceCoredumpUnregisterCoredumpHandler(void) {
thread->join();
return Ok;
}
EXPORT SYSV_ABI int32_t sceCoredumpSetUserDataType(int type) {
LOG_USE_MODULE(libSceCoredump);
LOG_ERR(L"todo %S type:%d", __FUNCTION__, type);
return Ok;
}
EXPORT SYSV_ABI size_t sceCoredumpWriteUserData(const void* data, size_t size) {
LOG_USE_MODULE(libSceCoredump);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI void sceCoredumpDebugTextOut(const char* str, int len) {
LOG_USE_MODULE(libSceCoredump);
LOG_ERR(L"todo %S", __FUNCTION__);
}
EXPORT SYSV_ABI int32_t sceCoredumpAttachUserFile(uint32_t user_value, const char* path) {
LOG_USE_MODULE(libSceCoredump);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceCoredumpAttachMemoryRegionAsUserFile(uint32_t user_value, const void* mem, size_t size, const char* name) {
LOG_USE_MODULE(libSceCoredump);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceCoredumpAttachMemoryRegion(uint32_t user_value, const void* mem, size_t size) {
LOG_USE_MODULE(libSceCoredump);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceCoredumpAttachUserMemoryFile(uint32_t user_value, const void* mem, size_t size) {
LOG_USE_MODULE(libSceCoredump);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceCoredumpGetStopInfoCpu(SceCoredumpStopInfoCpu* info, size_t size) {
LOG_USE_MODULE(libSceCoredump);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceCoredumpGetStopInfoGpu(SceCoredumpStopInfoGpu* info, size_t size) {
LOG_USE_MODULE(libSceCoredump);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceCoredumpGetThreadContextInfo(SceCoredumpThreadContextInfo* threadContextInfo, size_t threadContextInfoSize) {
LOG_USE_MODULE(libSceCoredump);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI void sceCoredumpDebugTriggerCoredump(void) {
LOG_USE_MODULE(libSceCoredump);
LOG_ERR(L"todo %S", __FUNCTION__);
}
EXPORT SYSV_ABI void sceCoredumpDebugForceCoredumpOnAppClose(void) {
LOG_USE_MODULE(libSceCoredump);
LOG_ERR(L"todo %S", __FUNCTION__);

2
modules/libSceGraphicsDriver/entry.cpp
View File

@ -1,9 +1,9 @@
#include "common.h"
#include "core/kernel/eventqueue_types.h"
#include "logging.h"
#include "types.h"
#include <graphics.h>
#include <logging.h>
#include <pm4_custom.h>
#include <timer.h>
#include <videoOut.h>

61
modules/libSceHttp/entry.cpp
View File

@ -1,11 +1,10 @@
#include "../libSceSsl/types.h"
#include "common.h"
#include "httpsTypes.h"
#include "logging.h"
#include "types.h"
#include "utility/utility.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceHttp);
namespace {
@ -21,163 +20,215 @@ EXPORT SYSV_ABI int sceHttpInit(int libnetMemId, int libsslCtxId, size_t poolSiz
static int id = 0;
return ++id;
}
EXPORT SYSV_ABI int sceHttpTerm(int libhttpCtxId) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpGetMemoryPoolStats(int libhttpCtxId, SceHttpMemoryPoolStats* currentStat) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpCreateTemplate(int libhttpCtxId, const char* userAgent, int httpVer, int isAutoProxyConf) {
static int id = 0;
return ++id;
}
EXPORT SYSV_ABI int sceHttpDeleteTemplate(int tmplId) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpCreateConnection(int tmplId, const char* serverName, const char* scheme, uint16_t port, int isEnableKeepalive) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpCreateConnectionWithURL(int tmplId, const char* url, int isEnableKeepalive) {
static int id = 0;
// return ++id;
return Err::CONNECT_TIMEOUT;
}
EXPORT SYSV_ABI int sceHttpDeleteConnection(int connId) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpCreateRequest(int connId, int method, const char* path, uint64_t contentLength) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpCreateRequest2(int connId, const char* method, const char* path, uint64_t contentLength) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpCreateRequestWithURL(int connId, int method, const char* url, uint64_t contentLength) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpCreateRequestWithURL2(int connId, const char* method, const char* url, uint64_t contentLength) {
return Err::SEND_TIMEOUT;
}
EXPORT SYSV_ABI int sceHttpDeleteRequest(int reqId) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpSetRequestContentLength(int id, uint64_t contentLength) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpSetChunkedTransferEnabled(int id, int isEnable) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpSetInflateGZIPEnabled(int id, int isEnable) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpSendRequest(int reqId, const void* postData, size_t size) {
return Err::SEND_TIMEOUT;
}
EXPORT SYSV_ABI int sceHttpAbortRequest(int reqId) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpGetResponseContentLength(int reqId, int* result, uint64_t* contentLength) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpGetStatusCode(int reqId, int* statusCode) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpGetAllResponseHeaders(int reqId, char** header, size_t* headerSize) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpReadData(int reqId, void* data, size_t size) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpAddRequestHeader(int id, const char* name, const char* value, uint32_t mode) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpRemoveRequestHeader(int id, const char* name) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpParseResponseHeader(const char* header, size_t headerLen, const char* fieldStr, const char** fieldValue, size_t* valueLen) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpParseStatusLine(const char* statusLine, size_t lineLen, int* httpMajorVer, int* httpMinorVer, int* responseCode,
const char** reasonPhrase, size_t* phraseLen) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpSetResponseHeaderMaxSize(int id, size_t headerSize) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpSetAuthInfoCallback(int id, SceHttpAuthInfoCallback cbfunc, void* userArg) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpSetAuthEnabled(int id, int isEnable) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpGetAuthEnabled(int id, int* isEnable) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpAuthCacheFlush(int libhttpCtxId) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpSetRedirectCallback(int id, SceHttpRedirectCallback cbfunc, void* userArg) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpSetAutoRedirect(int id, int isEnable) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpGetAutoRedirect(int id, int* isEnable) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpRedirectCacheFlush(int libhttpCtxId) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpSetResolveTimeOut(int id, uint32_t usec) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpSetResolveRetry(int id, int retry) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpSetConnectTimeOut(int id, uint32_t usec) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpSetSendTimeOut(int id, uint32_t usec) {
return Err::SEND_TIMEOUT;
}
EXPORT SYSV_ABI int sceHttpSetRecvTimeOut(int id, uint32_t usec) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpSetRequestStatusCallback(int id, SceHttpRequestStatusCallback cbfunc, void* userArg) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpGetLastErrno(int reqId, int* errNum) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpSetNonblock(int id, int isEnable) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpGetNonblock(int id, int* isEnable) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpTrySetNonblock(int id, int isEnable) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpTryGetNonblock(int id, int* isEnable) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpCreateEpoll(int libhttpCtxId, SceHttpEpollHandle* eh) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpSetEpoll(int id, SceHttpEpollHandle eh, void* userArg) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpUnsetEpoll(int id) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpGetEpoll(int id, SceHttpEpollHandle* eh, void** userArg) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpDestroyEpoll(int libhttpCtxId, SceHttpEpollHandle eh) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpWaitRequest(SceHttpEpollHandle eh, SceHttpNBEvent* nbev, int maxevents, int timeout) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpAbortWaitRequest(SceHttpEpollHandle eh) {
return Ok;
}
@ -186,21 +237,27 @@ EXPORT SYSV_ABI int sceHttpAbortWaitRequest(SceHttpEpollHandle eh) {
EXPORT SYSV_ABI int sceHttpsLoadCert(int libhttpCtxId, int caCertNum, const SceSslData** caList, const SceSslData* cert, const SceSslData* privKey) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpsUnloadCert(int libhttpCtxId) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpsEnableOption(int id, uint32_t sslFlags) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpsDisableOption(int id, uint32_t sslFlags) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpsGetSslError(int id, int* errNum, uint32_t* detail) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpsSetSslCallback(int id, SceHttpsCallback cbfunc, void* userArg) {
return Ok;
}
EXPORT SYSV_ABI int sceHttpsSetSslVersion(int id, SceSslVersion version) {
return Ok;
}

21
modules/libSceIme/entry.cpp
View File

@ -1,8 +1,7 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceIme);
namespace {} // namespace
@ -14,46 +13,61 @@ EXPORT const char* MODULE_NAME = "libSceIme";
EXPORT SYSV_ABI int sceImeOpen(const SceImeParam* param, const SceImeParamExtended* extParam) {
return Ok;
}
EXPORT SYSV_ABI int sceImeUpdate(SceImeEventHandler handler) {
return Ok;
}
EXPORT SYSV_ABI int sceImeSetText(const wchar_t* text, uint32_t length) {
return Ok;
}
EXPORT SYSV_ABI int sceImeSetCaret(const SceImeCaret* caret) {
return Ok;
}
EXPORT SYSV_ABI int sceImeSetTextGeometry(SceImeTextAreaMode mode, const SceImeTextGeometry* geometry) {
return Ok;
}
EXPORT SYSV_ABI int sceImeGetPanelSize(const SceImeParam* param, uint32_t* width, uint32_t* height) {
return Ok;
}
EXPORT SYSV_ABI int sceImeClose(void) {
return Ok;
}
EXPORT SYSV_ABI int sceImeGetPanelPositionAndForm(SceImePositionAndForm* posForm) {
return Ok;
}
EXPORT SYSV_ABI int sceImeSetCandidateIndex(int32_t index) {
return Ok;
}
EXPORT SYSV_ABI int sceImeConfirmCandidate(int32_t index) {
return Ok;
}
EXPORT SYSV_ABI int sceImeDisableController(void) {
return Ok;
}
EXPORT SYSV_ABI void sceImeParamInit(SceImeParam* param) {}
EXPORT SYSV_ABI int sceImeKeyboardOpen(SceUserServiceUserId userId, const SceImeKeyboardParam* param) {
EXPORT SYSV_ABI int sceImeKeyboardOpen(SceUserServiceUserId userId, const SceImeKeyboardParam* param) {
return Ok;
}
EXPORT SYSV_ABI int sceImeKeyboardClose(SceUserServiceUserId userId) {
return Ok;
}
EXPORT SYSV_ABI int sceImeKeyboardGetResourceId(SceUserServiceUserId userId, SceImeKeyboardResourceIdArray* resourceIdArray) {
return Ok;
}
EXPORT SYSV_ABI int sceImeKeyboardGetInfo(uint32_t resourceId, SceImeKeyboardInfo* info) {
info->userId = -1;
info->device = SceImeKeyboardDeviceType::KEYBOARD;
@ -64,6 +78,7 @@ EXPORT SYSV_ABI int sceImeKeyboardGetInfo(uint32_t resourceId, SceImeKeyboardInf
return Ok;
}
EXPORT SYSV_ABI int sceImeKeyboardSetMode(SceUserServiceUserId userId, uint32_t mode) {
return Ok;
}

6
modules/libSceMouse/entry.cpp
View File

@ -1,8 +1,7 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceMouse);
namespace {} // namespace
@ -14,12 +13,15 @@ EXPORT const char* MODULE_NAME = "libSceMouse";
EXPORT SYSV_ABI int sceMouseInit(void) {
return Ok;
}
EXPORT SYSV_ABI int sceMouseOpen(SceUserServiceUserId userId, int32_t type, int32_t index, const SceMouseOpenParam* pParam) {
return Ok;
}
EXPORT SYSV_ABI int sceMouseClose(int32_t handle) {
return Ok;
}
EXPORT SYSV_ABI int sceMouseRead(int32_t handle, SceMouseData* pData, int32_t num) {
pData[0] = SceMouseData();
return 1;

12
modules/libSceMove/entry.cpp
View File

@ -1,8 +1,7 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceMove);
namespace {} // namespace
@ -14,36 +13,45 @@ EXPORT const char* MODULE_NAME = "libSceMove";
EXPORT SYSV_ABI int sceMoveInit(void) {
return Ok;
}
EXPORT SYSV_ABI int sceMoveTerm(void) {
return Ok;
}
EXPORT SYSV_ABI int sceMoveOpen(SceUserServiceUserId userId, int32_t type, int32_t index) {
LOG_USE_MODULE(libSceMove);
LOG_DEBUG(L"open userId:%d type:%d index:%d", userId, type, index);
return Ok;
}
EXPORT SYSV_ABI int sceMoveClose(int32_t handle) {
return Ok;
}
EXPORT SYSV_ABI RetValues sceMoveReadStateRecent(int32_t handle, int64_t timestamp, SceMoveData* pData, int32_t* pNum) {
*pData = SceMoveData();
*pNum = 0;
return RetValues::NO_CONTROLLER_CONNECTED;
}
EXPORT SYSV_ABI RetValues sceMoveReadStateLatest(int32_t handle, SceMoveData* pData) {
*pData = SceMoveData();
return RetValues::NO_CONTROLLER_CONNECTED;
}
EXPORT SYSV_ABI int sceMoveSetLightSphere(int32_t handle, uint8_t r, uint8_t g, uint8_t b) {
return Ok;
}
EXPORT SYSV_ABI RetValues sceMoveSetVibration(int32_t handle, uint8_t motor) {
return RetValues::NO_CONTROLLER_CONNECTED;
}
EXPORT SYSV_ABI RetValues sceMoveGetDeviceInfo(int32_t handle, SceMoveDeviceInfo* pInfo) {
*pInfo = SceMoveDeviceInfo();
return RetValues::NO_CONTROLLER_CONNECTED;
}
EXPORT SYSV_ABI int sceMoveResetLightSphere(int32_t handle) {
return Ok;
}

26
modules/libSceNet/entry.cpp
View File

@ -1,8 +1,7 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceNet);
namespace {
@ -21,65 +20,84 @@ EXPORT SYSV_ABI int* sceNetErrnoLoc() {
EXPORT SYSV_ABI int sceNetInit(void) {
return Ok;
}
EXPORT SYSV_ABI int sceNetTerm(void) {
return Ok;
}
EXPORT SYSV_ABI int sceNetPoolCreate(const char* name, int size, int flags) {
static int id = 0;
return ++id;
return Ok;
}
EXPORT SYSV_ABI int sceNetPoolDestroy(int memid) {
return Ok;
}
EXPORT SYSV_ABI int sceNetGetMemoryPoolStats(int memid, SceNetMemoryPoolStats* stat) {
return Ok;
}
EXPORT SYSV_ABI int sceNetShowIfconfig(void) {
return Ok;
}
EXPORT SYSV_ABI int sceNetShowIfconfigWithMemory(int memid) {
return Ok;
}
EXPORT SYSV_ABI int sceNetShowRoute(void) {
return Ok;
}
EXPORT SYSV_ABI int sceNetShowRouteWithMemory(int memid) {
return Ok;
}
EXPORT SYSV_ABI int sceNetShowNetstat(void) {
return Ok;
}
EXPORT SYSV_ABI int sceNetShowNetstatWithMemory(int memid) {
return Ok;
}
EXPORT SYSV_ABI int sceNetShowPolicy(void) {
return Ok;
}
EXPORT SYSV_ABI int sceNetShowPolicyWithMemory(int memid) {
return Ok;
}
const char* sceNetInetNtop(int af, const void* src, char* dst, size_t size);
const char* sceNetInetNtop(int af, const void* src, char* dst, size_t size);
EXPORT SYSV_ABI int sceNetInetPton(int af, const char* src, void* dst) {
*static_cast<uint32_t*>(dst) = 0x7f000001;
return Ok;
}
EXPORT SYSV_ABI uint64_t sceNetHtonll(uint64_t host64) {
return Ok;
}
EXPORT SYSV_ABI uint32_t sceNetHtonl(uint32_t host32) {
return Ok;
}
EXPORT SYSV_ABI uint16_t sceNetHtons(uint16_t host16) {
return Ok;
}
EXPORT SYSV_ABI uint64_t sceNetNtohll(uint64_t net64) {
return Ok;
}
EXPORT SYSV_ABI uint32_t sceNetNtohl(uint32_t net32) {
return Ok;
}
EXPORT SYSV_ABI uint16_t sceNetNtohs(uint16_t net16) {
return Ok;
}
@ -87,11 +105,13 @@ EXPORT SYSV_ABI uint16_t sceNetNtohs(uint16_t net16) {
EXPORT SYSV_ABI int sceNetEtherStrton(const char* str, SceNetEtherAddr* n) {
return Ok;
}
EXPORT SYSV_ABI int sceNetEtherNtostr(const SceNetEtherAddr* n, char* str, size_t len) {
auto const count = std::string("00:00:00:00:00:00").copy(str, len);
str[count] = '\0';
return Ok;
}
EXPORT SYSV_ABI int sceNetGetMacAddress(SceNetEtherAddr* addr, int flags) {
memset(addr->data, 0, sizeof(addr->data));
return Ok;

7
modules/libSceNet/epoll.cpp
View File

@ -1,8 +1,7 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceNet);
namespace {
@ -39,15 +38,19 @@ EXPORT SYSV_ABI SceNetId sceNetEpollCreate(const char* name, int flags) {
static int id = 0;
return ++id;
}
EXPORT SYSV_ABI int sceNetEpollControl(SceNetId eid, int op, SceNetId id, SceNetEpollEvent* event) {
return Ok;
}
EXPORT SYSV_ABI int sceNetEpollWait(SceNetId eid, SceNetEpollEvent* events, int maxevents, int timeout) {
return Ok;
}
EXPORT SYSV_ABI int sceNetEpollDestroy(SceNetId eid) {
return Ok;
}
EXPORT SYSV_ABI int sceNetEpollAbort(SceNetId eid, int flags) {
return Ok;
}

20
modules/libSceNet/socket.cpp
View File

@ -1,7 +1,6 @@
#include "common.h"
#include "logging.h"
#include "socketTypes.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceNet);
namespace {} // namespace
@ -11,6 +10,7 @@ extern "C" {
EXPORT SYSV_ABI SceNetId sceNetSocket(const char* name, int domain, int type, int protocol) {
return Ok;
}
EXPORT SYSV_ABI SceNetId sceNetAccept(SceNetId s, SceNetSockaddr* addr, SceNetSocklen_t* addrlen) {
if (addr != nullptr)
*addr = SceNetSockaddr {
@ -21,51 +21,67 @@ EXPORT SYSV_ABI SceNetId sceNetAccept(SceNetId s, SceNetSockaddr* addr, SceNetSo
return Ok;
}
EXPORT SYSV_ABI int sceNetBind(SceNetId s, const SceNetSockaddr* addr, SceNetSocklen_t addrlen) {
return Ok;
}
EXPORT SYSV_ABI int sceNetConnect(SceNetId s, const SceNetSockaddr* name, SceNetSocklen_t namelen) {
return Ok;
}
EXPORT SYSV_ABI int sceNetGetpeername(SceNetId s, SceNetSockaddr* name, SceNetSocklen_t* namelen) {
return Ok;
}
EXPORT SYSV_ABI int sceNetGetsockname(SceNetId s, SceNetSockaddr* name, SceNetSocklen_t* namelen) {
return Ok;
}
EXPORT SYSV_ABI int sceNetGetsockopt(SceNetId s, int level, int optname, void* optval, SceNetSocklen_t* optlen) {
return Ok;
}
EXPORT SYSV_ABI int sceNetListen(SceNetId s, int backlog) {
return Ok;
}
EXPORT SYSV_ABI int sceNetRecv(SceNetId s, void* buf, size_t len, int flags) {
return Ok;
}
EXPORT SYSV_ABI int sceNetRecvfrom(SceNetId s, void* buf, size_t len, int flags, SceNetSockaddr* from, SceNetSocklen_t* fromlen) {
return Ok;
}
EXPORT SYSV_ABI int sceNetRecvmsg(SceNetId s, SceNetMsghdr* msg, int flags) {
return Ok;
}
EXPORT SYSV_ABI int sceNetSend(SceNetId s, const void* msg, size_t len, int flags) {
return Ok;
}
EXPORT SYSV_ABI int sceNetSendto(SceNetId s, const void* msg, size_t len, int flags, const SceNetSockaddr* to, SceNetSocklen_t tolen) {
return Ok;
}
EXPORT SYSV_ABI int sceNetSendmsg(SceNetId s, const SceNetMsghdr* msg, int flags) {
return Ok;
}
EXPORT SYSV_ABI int sceNetSetsockopt(SceNetId s, int level, int optname, const void* optval, SceNetSocklen_t optlen) {
return Ok;
}
EXPORT SYSV_ABI int sceNetShutdown(SceNetId s, int how) {
return Ok;
}
EXPORT SYSV_ABI int sceNetSocketClose(SceNetId s) {
return Ok;
}
EXPORT SYSV_ABI int sceNetSocketAbort(SceNetId s, int flags) {
return Ok;
}

14
modules/libSceNetCtl/entry.cpp
View File

@ -1,8 +1,7 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceNetCtl);
namespace {} // namespace
@ -14,24 +13,31 @@ EXPORT const char* MODULE_NAME = "libSceNetCtl";
EXPORT SYSV_ABI int sceNetCtlInit(void) {
return Ok;
}
EXPORT SYSV_ABI void sceNetCtlTerm(void) {}
EXPORT SYSV_ABI int sceNetCtlCheckCallback(void) {
EXPORT SYSV_ABI int sceNetCtlCheckCallback(void) {
return Ok;
}
EXPORT SYSV_ABI int sceNetCtlRegisterCallback(SceNetCtlCallback func, void* arg, int* cid) {
*cid = 1;
return Ok;
}
EXPORT SYSV_ABI int sceNetCtlUnregisterCallback(int cid) {
return Ok;
}
EXPORT SYSV_ABI int sceNetCtlGetResult(int eventType, int* errorCode) {
return Ok;
}
EXPORT SYSV_ABI int sceNetCtlGetState(int* state) {
*state = 0;
return Ok;
}
EXPORT SYSV_ABI int sceNetCtlGetInfo(int code, SceNetCtlInfo* info) {
LOG_USE_MODULE(libSceNetCtl);
@ -47,9 +53,11 @@ EXPORT SYSV_ABI int sceNetCtlGetInfo(int code, SceNetCtlInfo* info) {
}
return Ok;
}
EXPORT SYSV_ABI int sceNetCtlGetIfStat(SceNetCtlIfStat* ifStat) {
return Ok;
}
EXPORT SYSV_ABI int sceNetCtlGetNatInfo(SceNetCtlNatInfo* natInfo) {
natInfo->stunStatus = 1;
natInfo->natType = 3;

50
modules/libSceNpManager/entry.cpp
View File

@ -1,7 +1,7 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
#include <utility/utility.h>
LOG_DEFINE_MODULE(libSceNpManager);
@ -22,77 +22,92 @@ EXPORT SYSV_ABI int sceNpSetNpTitleId(const SceNpTitleId* titleId, const SceNpTi
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpSetContentRestriction(const SceNpContentRestriction* pRestriction) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpCheckCallback(void) {
// todo iterate callbacks
return Ok;
}
EXPORT SYSV_ABI int sceNpGetState(int32_t userId, SceNpState* state) {
*state = SceNpState::SIGNED_OUT;
return Ok;
}
EXPORT SYSV_ABI int sceNpRegisterStateCallback(SceNpStateCallbackA callback, void* userdata) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpUnregisterStateCallback(int callbackId) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpRegisterStateCallbackA(SceNpStateCallbackA callback, void* userdata) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpUnregisterStateCallbackA(int callbackId) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpGetNpReachabilityState(int32_t userId, SceNpReachabilityState* state) {
*state = SceNpReachabilityState::UNAVAILABLE;
return Ok;
}
EXPORT SYSV_ABI int sceNpRegisterNpReachabilityStateCallback(SceNpReachabilityStateCallback callback, void* userdata) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpUnregisterNpReachabilityStateCallback(void) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpHasSignedUp(int32_t userId, bool* hasSignedUp) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
*hasSignedUp = true;
return Ok;
}
EXPORT SYSV_ABI int sceNpGetAccountId(int32_t userId, SceNpAccountId* accountId) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
*accountId = 1;
return Ok;
}
EXPORT SYSV_ABI int sceNpGetAccountIdA(int32_t userId, SceNpAccountId* accountId) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
*accountId = 1;
return Ok;
}
EXPORT SYSV_ABI int sceNpGetUserIdByAccountId(SceNpAccountId accountId, int32_t* userId) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
*userId = 1;
return Ok;
}
EXPORT SYSV_ABI int sceNpGetOnlineId(int32_t userId, SceNpOnlineId* onlineId) {
auto const count = std::string("onlineId").copy(onlineId->data, 15);
onlineId->data[count] = '\0';
@ -102,6 +117,7 @@ EXPORT SYSV_ABI int sceNpGetOnlineId(int32_t userId, SceNpOnlineId* onlineId) {
LOG_ERR(L"todo %S, userId:%d", __FUNCTION__, userId);
return Ok;
}
EXPORT SYSV_ABI int sceNpGetNpId(int32_t userId, SceNpId* npId) {
auto const count = std::string("NpIdName").copy(npId->handle.data, 15);
npId->handle.data[count] = '\0';
@ -110,21 +126,25 @@ EXPORT SYSV_ABI int sceNpGetNpId(int32_t userId, SceNpId* npId) {
LOG_DEBUG(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpGetPlatformType(const SceNpId* npId) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return (int)SceNpPlatformType::TYPE_PS4;
}
EXPORT SYSV_ABI int sceNpSetPlatformType(SceNpId* npId, SceNpPlatformType platformType) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpGetAccountCountry(int32_t userId, SceNpCountryCode* countryCode) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpGetAccountDateOfBirth(int32_t userId, SceNpDate* dateOfBirth) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
@ -134,55 +154,65 @@ EXPORT SYSV_ABI int sceNpGetAccountDateOfBirth(int32_t userId, SceNpDate* dateOf
dateOfBirth->day = 1;
return Ok;
}
EXPORT SYSV_ABI int sceNpRegisterGamePresenceCallback(SceNpGamePresenceCallbackA callback, void* userdata) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpUnregisterGamePresenceCallback(int callbackId) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpGetGamePresenceStatus(int32_t userId, SceNpGamePresenceStatus* status) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
*status = SceNpGamePresenceStatus::OFFLINE;
return Ok;
}
EXPORT SYSV_ABI int sceNpGetAccountCountryA(int32_t userId, SceNpCountryCode* countryCode) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpGetAccountDateOfBirthA(int32_t userId, SceNpDate* dateOfBirth) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpRegisterGamePresenceCallbackA(SceNpGamePresenceCallbackA callback, void* userdata) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpUnregisterGamePresenceCallbackA(int callbackId) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpGetGamePresenceStatusA(int32_t userId, SceNpGamePresenceStatus* status) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
*status = SceNpGamePresenceStatus::OFFLINE;
return Ok;
}
EXPORT SYSV_ABI int sceNpCreateRequest(void) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
static int32_t id = 0;
return ++id;
}
EXPORT SYSV_ABI int sceNpCreateAsyncRequest(const SceNpCreateAsyncRequestParameter* param) {
LOG_USE_MODULE(libSceNpManager);
@ -190,63 +220,75 @@ EXPORT SYSV_ABI int sceNpCreateAsyncRequest(const SceNpCreateAsyncRequestParamet
static int32_t id = 0;
return ++id;
}
EXPORT SYSV_ABI int sceNpDeleteRequest(int reqId) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpAbortRequest(int reqId) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpSetTimeout(int reqId, int32_t resolveRetry, uint32_t resolveTimeout, uint32_t connTimeout, uint32_t sendTimeout,
uint32_t recvTimeout) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpWaitAsync(int reqId, int* result) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpPollAsync(int reqId, int* result) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
*result = 0;
return Ok;
}
EXPORT SYSV_ABI int sceNpGetAccountLanguage(int reqId, int32_t userId, SceNpLanguageCode* langCode) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpGetParentalControlInfo(int reqId, int32_t userId, int8_t* age, SceNpParentalControlInfo* info) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpCheckNpAvailability(int reqId, int32_t userId) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpCheckNpReachability(int reqId, int32_t userId) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpSetGamePresenceOnline(int reqId, int32_t userId, uint32_t timeout, void* pReserved) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpGetAccountLanguageA(int reqId, int32_t userId, SceNpLanguageCode* langCode) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpGetParentalControlInfoA(int reqId, int32_t userId, int8_t* age, SceNpParentalControlInfo* info) {
info->chatRestriction = false;
info->contentRestriction = false;
@ -254,16 +296,19 @@ EXPORT SYSV_ABI int sceNpGetParentalControlInfoA(int reqId, int32_t userId, int8
*age = 18;
return Ok;
}
EXPORT SYSV_ABI int sceNpCheckNpAvailabilityA(int reqId, int32_t userId) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpSetGamePresenceOnlineA(int reqId, int32_t userId, uint32_t timeout, void* pReserved) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpCheckPlus(int reqId, const SceNpCheckPlusParameter* param, SceNpCheckPlusResult* pResult) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
@ -271,16 +316,19 @@ EXPORT SYSV_ABI int sceNpCheckPlus(int reqId, const SceNpCheckPlusParameter* par
return Ok;
}
EXPORT SYSV_ABI int sceNpRegisterPlusEventCallback(SceNpPlusEventCallback callback, void* userdata) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpUnregisterPlusEventCallback(void) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpNotifyPlusFeature(const SceNpNotifyPlusFeatureParameter* param) {
LOG_USE_MODULE(libSceNpManager);
LOG_ERR(L"todo %S", __FUNCTION__);

5
modules/libSceNpManagerForToolkit/entry.cpp
View File

@ -1,8 +1,7 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceNpManagerForToolkit);
namespace {} // namespace
@ -14,9 +13,11 @@ EXPORT const char* MODULE_NAME = "libSceNpManager";
EXPORT SYSV_ABI int sceNpCheckCallbackForLib() {
return Ok;
}
EXPORT SYSV_ABI int sceNpRegisterStateCallbackForToolkit(void* /*callback*/, void* /*userdata*/) {
return Ok;
}
EXPORT SYSV_ABI int sceNpUnregisterStateCallbackForToolkit(void* /*callback*/, void* /*userdata*/) {
return Ok;
}

40
modules/libSceNpScore/entry.cpp
View File

@ -1,7 +1,6 @@
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceNpScore);
namespace {} // namespace
@ -15,71 +14,84 @@ EXPORT SYSV_ABI int sceNpScoreCreateNpTitleCtxA(SceNpServiceLabel serviceLabel,
LOG_ERR(L"todo %S", __FUNCTION__);
return 1;
}
EXPORT SYSV_ABI int sceNpScoreDeleteNpTitleCtx(int32_t titleCtxId) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreCreateRequest(int32_t titleCtxId) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreDeleteRequest(int32_t reqId) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreAbortRequest(int32_t reqId) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreSetTimeout(int32_t id, int32_t resolveRetry, int32_t resolveTimeout, int32_t connTimeout, int32_t sendTimeout,
int32_t recvTimeout) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreSetThreadParam(int32_t threadPriority, SceKernelCpumask cpuAffinityMask) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreSetPlayerCharacterId(int32_t id, SceNpScorePcId pcId) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetBoardInfo(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreBoardInfo* boardInfo, void* option) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreRecordScore(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreValue score, const SceNpScoreComment* scoreComment,
const SceNpScoreGameInfo* gameInfo, SceNpScoreRankNumber* tmpRank, const SceRtcTick* compareDate, void* option) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreRecordGameData(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreValue score, size_t totalSize, size_t sendSize,
const void* data, void* option) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetGameDataByAccountId(int32_t reqId, SceNpScoreBoardId boardId, SceNpAccountId accountId, size_t* totalSize, size_t recvSize,
void* data, void* option) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetGameDataByAccountIdAsync(int32_t reqId, SceNpScoreBoardId boardId, SceNpAccountId accountId, size_t* totalSize,
size_t recvSize, void* data, void* option) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountId(int32_t reqId, SceNpScoreBoardId boardId, const SceNpAccountId accountIdArray[], size_t accountIdArraySize,
SceNpScorePlayerRankDataA* rankArray, size_t rankArraySize, SceNpScoreComment* commentArray,
size_t commentArraySize, SceNpScoreGameInfo* infoArray, size_t infoArraySize, size_t arrayNum,
@ -88,6 +100,7 @@ EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountId(int32_t reqId, SceNpScoreBoa
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdForCrossSave(int32_t reqId, SceNpScoreBoardId boardId, const SceNpAccountId accountIdArray[],
size_t accountIdArraySize, SceNpScorePlayerRankDataForCrossSave* rankArray,
size_t rankArraySize, SceNpScoreComment* commentArray, size_t commentArraySize,
@ -97,6 +110,7 @@ EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdForCrossSave(int32_t reqId, S
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetRankingByRangeA(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreRankNumber startSerialRank, SceNpScoreRankDataA* rankArray,
size_t rankArraySize, SceNpScoreComment* commentArray, size_t commentArraySize, SceNpScoreGameInfo* infoArray,
size_t infoArraySize, size_t arrayNum, SceRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord,
@ -105,6 +119,7 @@ EXPORT SYSV_ABI int sceNpScoreGetRankingByRangeA(int32_t reqId, SceNpScoreBoardI
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetRankingByRangeForCrossSave(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreRankNumber startSerialRank,
SceNpScoreRankDataForCrossSave* rankArray, size_t rankArraySize, SceNpScoreComment* commentArray,
size_t commentArraySize, SceNpScoreGameInfo* infoArray, size_t infoArraySize, size_t arrayNum,
@ -113,6 +128,7 @@ EXPORT SYSV_ABI int sceNpScoreGetRankingByRangeForCrossSave(int32_t reqId, SceNp
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdPcId(int32_t reqId, SceNpScoreBoardId boardId, const SceNpScoreAccountIdPcId* idArray, size_t idArraySize,
SceNpScorePlayerRankDataA* rankArray, size_t rankArraySize, SceNpScoreComment* commentArray,
size_t commentArraySize, SceNpScoreGameInfo* infoArray, size_t infoArraySize, size_t arrayNum,
@ -121,6 +137,7 @@ EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdPcId(int32_t reqId, SceNpScor
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdPcIdForCrossSave(int32_t reqId, SceNpScoreBoardId boardId, const SceNpScoreAccountIdPcId* idArray,
size_t idArraySize, SceNpScorePlayerRankDataForCrossSave* rankArray, size_t rankArraySize,
SceNpScoreComment* commentArray, size_t commentArraySize, SceNpScoreGameInfo* infoArray,
@ -130,43 +147,51 @@ EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdPcIdForCrossSave(int32_t reqI
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreCensorComment(int32_t reqId, const char* comment, void* option) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreSanitizeComment(int32_t reqId, const char* comment, char* sanitizedComment, void* option) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreWaitAsync(int32_t id, int32_t* result) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScorePollAsync(int32_t reqId, int32_t* result) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetBoardInfoAsync(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreBoardInfo* boardInfo, void* option) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreRecordScoreAsync(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreValue score, const SceNpScoreComment* scoreComment,
const SceNpScoreGameInfo* gameInfo, SceNpScoreRankNumber* tmpRank, const SceRtcTick* compareDate, void* option) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreRecordGameDataAsync(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreValue score, size_t totalSize, size_t sendSize,
const void* data, void* option) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdAsync(int32_t reqId, SceNpScoreBoardId boardId, const SceNpAccountId accountIdArray[],
size_t accountIdArraySize, SceNpScorePlayerRankDataA* rankArray, size_t rankArraySize,
SceNpScoreComment* commentArray, size_t commentArraySize, SceNpScoreGameInfo* infoArray,
@ -176,6 +201,7 @@ EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdAsync(int32_t reqId, SceNpSco
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdForCrossSaveAsync(int32_t reqId, SceNpScoreBoardId boardId, const SceNpAccountId accountIdArray[],
size_t accountIdArraySize, SceNpScorePlayerRankDataForCrossSave* rankArray,
size_t rankArraySize, SceNpScoreComment* commentArray, size_t commentArraySize,
@ -185,6 +211,7 @@ EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdForCrossSaveAsync(int32_t req
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetRankingByRangeAAsync(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreRankNumber startSerialRank,
SceNpScoreRankDataA* rankArray, size_t rankArraySize, SceNpScoreComment* commentArray,
size_t commentArraySize, SceNpScoreGameInfo* infoArray, size_t infoArraySize, size_t arrayNum,
@ -193,6 +220,7 @@ EXPORT SYSV_ABI int sceNpScoreGetRankingByRangeAAsync(int32_t reqId, SceNpScoreB
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetRankingByRangeForCrossSaveAsync(int32_t reqId, SceNpScoreBoardId boardId, SceNpScoreRankNumber startSerialRank,
SceNpScoreRankDataForCrossSave* rankArray, size_t rankArraySize,
SceNpScoreComment* commentArray, size_t commentArraySize, SceNpScoreGameInfo* infoArray,
@ -202,6 +230,7 @@ EXPORT SYSV_ABI int sceNpScoreGetRankingByRangeForCrossSaveAsync(int32_t reqId,
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdPcIdAsync(int32_t reqId, SceNpScoreBoardId boardId, const SceNpScoreAccountIdPcId* idArray,
size_t idArraySize, SceNpScorePlayerRankDataA* rankArray, size_t rankArraySize,
SceNpScoreComment* commentArray, size_t commentArraySize, SceNpScoreGameInfo* infoArray,
@ -211,6 +240,7 @@ EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdPcIdAsync(int32_t reqId, SceN
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdPcIdForCrossSaveAsync(int32_t reqId, SceNpScoreBoardId boardId, const SceNpScoreAccountIdPcId* idArray,
size_t idArraySize, SceNpScorePlayerRankDataForCrossSave* rankArray,
size_t rankArraySize, SceNpScoreComment* commentArray, size_t commentArraySize,
@ -220,6 +250,7 @@ EXPORT SYSV_ABI int sceNpScoreGetRankingByAccountIdPcIdForCrossSaveAsync(int32_t
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetFriendsRankingA(int32_t reqId, SceNpScoreBoardId boardId, int32_t includeSelf, SceNpScoreRankDataA* rankArray,
size_t rankArraySize, SceNpScoreComment* commentArray, size_t commentArraySize, SceNpScoreGameInfo* infoArray,
size_t infoArraySize, size_t arrayNum, SceRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord,
@ -228,6 +259,7 @@ EXPORT SYSV_ABI int sceNpScoreGetFriendsRankingA(int32_t reqId, SceNpScoreBoardI
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetFriendsRankingAAsync(int32_t reqId, SceNpScoreBoardId boardId, int32_t includeSelf, SceNpScoreRankDataA* rankArray,
size_t rankArraySize, SceNpScoreComment* commentArray, size_t commentArraySize,
SceNpScoreGameInfo* infoArray, size_t infoArraySize, size_t arrayNum, SceRtcTick* lastSortDate,
@ -236,6 +268,7 @@ EXPORT SYSV_ABI int sceNpScoreGetFriendsRankingAAsync(int32_t reqId, SceNpScoreB
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetFriendsRankingForCrossSave(int32_t reqId, SceNpScoreBoardId boardId, int32_t includeSelf,
SceNpScoreRankDataForCrossSave* rankArray, size_t rankArraySize, SceNpScoreComment* commentArray,
size_t commentArraySize, SceNpScoreGameInfo* infoArray, size_t infoArraySize, size_t arrayNum,
@ -245,6 +278,7 @@ EXPORT SYSV_ABI int sceNpScoreGetFriendsRankingForCrossSave(int32_t reqId, SceNp
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreGetFriendsRankingForCrossSaveAsync(int32_t reqId, SceNpScoreBoardId boardId, int32_t includeSelf,
SceNpScoreRankDataForCrossSave* rankArray, size_t rankArraySize,
SceNpScoreComment* commentArray, size_t commentArraySize, SceNpScoreGameInfo* infoArray,
@ -254,11 +288,13 @@ EXPORT SYSV_ABI int sceNpScoreGetFriendsRankingForCrossSaveAsync(int32_t reqId,
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreCensorCommentAsync(int32_t reqId, const char* comment, void* option) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceNpScoreSanitizeCommentAsync(int32_t reqId, const char* comment, char* sanitizedComment, void* option) {
LOG_USE_MODULE(libSceNpScore);
LOG_ERR(L"todo %S", __FUNCTION__);

18
modules/libSceNpTrophy/entry.cpp
View File

@ -1,9 +1,8 @@
#include "../libSceNpManager/types.h"
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceNpTrophy);
namespace {} // namespace
@ -16,26 +15,33 @@ EXPORT SYSV_ABI int sceNpTrophyCreateHandle(SceNpTrophyHandle* handle) {
*handle = 1;
return Ok;
}
EXPORT SYSV_ABI int sceNpTrophyDestroyHandle(SceNpTrophyHandle handle) {
return Ok;
}
EXPORT SYSV_ABI int sceNpTrophyAbortHandle(SceNpTrophyHandle handle) {
return Ok;
}
EXPORT SYSV_ABI int sceNpTrophyCreateContext(SceNpTrophyContext* context, int32_t userId, SceNpServiceLabel serviceLabel, uint64_t options) {
*context = 1;
return Ok;
}
EXPORT SYSV_ABI int sceNpTrophyDestroyContext(SceNpTrophyContext context) {
return Ok;
}
EXPORT SYSV_ABI int sceNpTrophyRegisterContext(SceNpTrophyContext context, SceNpTrophyHandle handle, uint64_t options) {
return Ok;
}
EXPORT SYSV_ABI int sceNpTrophyUnlockTrophy(SceNpTrophyContext context, SceNpTrophyHandle handle, SceNpTrophyId trophyId, SceNpTrophyId* platinumId) {
*platinumId = Err::SCE_NP_TROPHY_INVALID_TROPHY_ID;
return Ok;
}
EXPORT SYSV_ABI int sceNpTrophyGetTrophyUnlockState(SceNpTrophyContext context, SceNpTrophyHandle handle, SceNpTrophyFlagArray* flags, uint32_t* count) {
flags->flagBits[0] = 0;
flags->flagBits[1] = 0;
@ -46,6 +52,7 @@ EXPORT SYSV_ABI int sceNpTrophyGetTrophyUnlockState(SceNpTrophyContext context,
return Ok;
}
EXPORT SYSV_ABI int sceNpTrophyGetGameInfo(SceNpTrophyContext context, SceNpTrophyHandle handle, SceNpTrophyGameDetails* details, SceNpTrophyGameData* data) {
details->numGroups = 0;
details->numTrophies = 1;
@ -67,6 +74,7 @@ EXPORT SYSV_ABI int sceNpTrophyGetGameInfo(SceNpTrophyContext context, SceNpTrop
}
return Ok;
}
EXPORT SYSV_ABI int sceNpTrophyGetGroupInfo(SceNpTrophyContext context, SceNpTrophyHandle handle, SceNpTrophyGroupId groupId, SceNpTrophyGroupDetails* details,
SceNpTrophyGroupData* data) {
if (details != nullptr) {
@ -92,6 +100,7 @@ EXPORT SYSV_ABI int sceNpTrophyGetGroupInfo(SceNpTrophyContext context, SceNpTro
}
return Ok;
}
EXPORT SYSV_ABI int sceNpTrophyGetTrophyInfo(SceNpTrophyContext context, SceNpTrophyHandle handle, SceNpTrophyId trophyId, SceNpTrophyDetails* details,
SceNpTrophyData* data) {
if (details != nullptr) {
@ -111,23 +120,28 @@ EXPORT SYSV_ABI int sceNpTrophyGetTrophyInfo(SceNpTrophyContext context, SceNpTr
}
return Ok;
}
EXPORT SYSV_ABI int sceNpTrophyGetGameIcon(SceNpTrophyContext context, SceNpTrophyHandle handle, void* buffer, size_t* size) {
*size = 8;
*(uint64_t*)buffer = 0;
return Ok;
}
EXPORT SYSV_ABI int sceNpTrophyGetGroupIcon(SceNpTrophyContext context, SceNpTrophyHandle handle, SceNpTrophyGroupId groupId, void* buffer, size_t* size) {
return Ok;
}
EXPORT SYSV_ABI int sceNpTrophyGetTrophyIcon(SceNpTrophyContext context, SceNpTrophyHandle handle, SceNpTrophyId trophyId, void* buffer, size_t* size) {
*size = 8;
*(uint64_t*)buffer = 0;
return Ok;
}
EXPORT SYSV_ABI int sceNpTrophyShowTrophyList(SceNpTrophyContext context, SceNpTrophyHandle handle) {
return Ok;
}
EXPORT SYSV_ABI int sceNpTrophyCaptureScreenshot(SceNpTrophyHandle handle, const SceNpTrophyScreenshotTarget* targets, uint32_t numTargets) {
return Ok;
}

36
modules/libSceNpWebApi/entry.cpp
View File

@ -1,9 +1,8 @@
#include "../libSceNpManager/types.h"
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceNpWebApi);
namespace {
@ -23,102 +22,133 @@ EXPORT SYSV_ABI int32_t sceNpWebApiCreateExtdPushEventFilter(int32_t libCtxId, i
const SceNpWebApiExtdPushEventFilterParameter* pFilterParam, size_t filterParamNum) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiDeleteExtdPushEventFilter(int32_t libCtxId, int32_t filterId) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiRegisterExtdPushEventCallbackA(int32_t userCtxId, int32_t filterId, SceNpWebApiExtdPushEventCallbackA cbFunc,
void* pUserArg) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiUnregisterExtdPushEventCallback(int32_t userCtxId, int32_t callbackId) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiInitialize(int libHttpCtxId, size_t poolSize) {
static int id = 0;
return ++id;
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiTerminate(int32_t libCtxId) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiCreateContextA(int32_t libCtxId, int32_t userId) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiDeleteContext(int32_t titleUserCtxId) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiCreateRequest(int32_t titleUserCtxId, const char* pApiGroup, const char* pPath, SceNpWebApiHttpMethod method,
const SceNpWebApiContentParameter* pContentParameter, int64_t* pRequestId) {
*pRequestId = 0;
return -1;
}
EXPORT SYSV_ABI int32_t sceNpWebApiCreateMultipartRequest(int32_t titleUserCtxId, const char* pApiGroup, const char* pPath, SceNpWebApiHttpMethod method,
int64_t* pRequestId) {
*pRequestId = 0;
return -1;
}
EXPORT SYSV_ABI int32_t sceNpWebApiDeleteRequest(int64_t requestId) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiSendRequest2(int64_t requestId, const void* pData, size_t dataSize, SceNpWebApiResponseInformationOption* pRespInfoOption) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiSendMultipartRequest2(int64_t requestId, int32_t partIndex, const void* pData, size_t dataSize,
SceNpWebApiResponseInformationOption* pRespInfoOption) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiReadData(int64_t requestId, void* pData, size_t size) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiSetMultipartContentType(int64_t requestId, const char* pTypeName, const char* pBoundary) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiAddMultipartPart(int64_t requestId, const SceNpWebApiMultipartPartParameter* pParam, int32_t* pIndex) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiAddHttpRequestHeader(int64_t requestId, const char* pFieldName, const char* pValue) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiGetHttpResponseHeaderValueLength(int64_t requestId, const char* pFieldName, size_t* pValueLength) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiGetHttpResponseHeaderValue(int64_t requestId, const char* pFieldName, char* pValue, size_t valueSize) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiAbortRequest(int64_t requestId) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiCreateHandle(int32_t libCtxId) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiDeleteHandle(int32_t libCtxId, int32_t handleId) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiAbortHandle(int32_t libCtxId, int32_t handleId) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiGetMemoryPoolStats(int32_t libCtxId, SceNpWebApiMemoryPoolStats* pCurrentStat) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiSetMaxConnection(int32_t libCtxId, int32_t maxConnection) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiClearUnusedConnection(int32_t userCtxId, const char* pApiGroup, bool bRemainKeepAliveConnection) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiClearAllUnusedConnection(int32_t userCtxId, bool bRemainKeepAliveConnection) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiGetConnectionStats(int32_t userCtxId, const char* pApiGroup, SceNpWebApiConnectionStats* pStats) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiSetRequestTimeout(int64_t requestId, uint32_t timeout) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceNpWebApiSetHandleTimeout(int32_t libCtxId, int32_t handleId, uint32_t timeout) {
return Ok;
}
EXPORT SYSV_ABI void sceNpWebApiCheckTimeout(void) {}
EXPORT SYSV_ABI void sceNpWebApiCheckTimeout(void) {}
EXPORT SYSV_ABI int32_t sceNpWebApiUtilityParseNpId(const char* pJsonNpId, SceNpId* pNpId) {
return Ok;
}

16
modules/libScePad/entry.cpp
View File

@ -1,7 +1,7 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
#include <timer.h>
#include <videoOut.h>
@ -130,6 +130,7 @@ ScePadData getPadData(int handle) {
};
}
} // namespace
extern "C" {
EXPORT const char* MODULE_NAME = "libScePad";
@ -138,6 +139,7 @@ EXPORT SYSV_ABI int scePadInit(void) {
glfwInit();
return glfwInit() ? Ok : Err::FATAL;
}
EXPORT SYSV_ABI int scePadOpen(int32_t userId, PadPortType type, int32_t index, const void* pParam) {
LOG_USE_MODULE(libScePad);
auto pData = getData();
@ -162,6 +164,7 @@ EXPORT SYSV_ABI int scePadOpen(int32_t userId, PadPortType type, int32_t index,
}
return Err::NO_HANDLE;
}
EXPORT SYSV_ABI int scePadClose(int32_t handle) {
if (handle < 0) return Ok;
@ -175,6 +178,7 @@ EXPORT SYSV_ABI int scePadClose(int32_t handle) {
return Ok;
}
EXPORT SYSV_ABI int scePadGetHandle(int32_t userId, PadPortType type, int32_t index) {
auto pData = getData();
LOG_USE_MODULE(libScePad);
@ -205,6 +209,7 @@ EXPORT SYSV_ABI int scePadRead(int32_t handle, ScePadData* pPadData, int32_t num
pData->controller[handle].prePadData = *pPadData;
return abs(retVal);
}
EXPORT SYSV_ABI int scePadReadState(int32_t handle, ScePadData* pData) {
auto ret = scePadRead(handle, pData, 1);
return ret >= 0 ? Ok : ret;
@ -214,30 +219,37 @@ EXPORT SYSV_ABI int scePadSetMotionSensorState(int32_t handle, bool bEnable) {
if (handle < 0) return Err::INVALID_HANDLE;
return Ok;
}
EXPORT SYSV_ABI int scePadSetTiltCorrectionState(int32_t handle, bool bEnable) {
if (handle < 0) return Err::INVALID_HANDLE;
return Ok;
}
EXPORT SYSV_ABI int scePadSetAngularVelocityDeadbandState(int32_t handle, bool bEnable) {
if (handle < 0) return Err::INVALID_HANDLE;
return Ok;
}
EXPORT SYSV_ABI int scePadResetOrientation(int32_t handle) {
if (handle < 0) return Err::INVALID_HANDLE;
return Ok;
}
EXPORT SYSV_ABI int scePadSetVibration(int32_t handle, const ScePadVibrationParam* pParam) {
if (handle < 0) return Err::INVALID_HANDLE;
return Ok;
}
EXPORT SYSV_ABI int scePadSetLightBar(int32_t handle, const ScePadColor* pParam) {
if (handle < 0) return Err::INVALID_HANDLE;
return Ok;
}
EXPORT SYSV_ABI int scePadResetLightBar(int32_t handle) {
if (handle < 0) return Err::INVALID_HANDLE;
return Ok;
}
EXPORT SYSV_ABI int scePadGetControllerInformation(int32_t handle, ScePadControllerInformation* pInfo) {
LOG_USE_MODULE(libScePad);
LOG_DEBUG(L"");
@ -280,12 +292,14 @@ EXPORT SYSV_ABI int scePadGetControllerInformation(int32_t handle, ScePadControl
LOG_DEBUG(L"handle:%d connected:%d", handle, pInfo->connected);
return Ok;
}
EXPORT SYSV_ABI int scePadDeviceClassParseData(int32_t handle, const ScePadData* pData, ScePadDeviceClassData* pDeviceClassData) {
LOG_USE_MODULE(libScePad);
LOG_DEBUG(L"");
if (handle < 0) return Err::INVALID_HANDLE;
return Ok;
}
EXPORT SYSV_ABI int scePadDeviceClassGetExtendedInformation(int32_t handle, ScePadDeviceClassExtendedInformation* pExtInfo) {
LOG_USE_MODULE(libScePad);
LOG_DEBUG(L"");

19
modules/libScePlayGo/entry.cpp
View File

@ -1,8 +1,7 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libScePlayGo);
namespace {
@ -19,9 +18,11 @@ EXPORT SYSV_ABI int32_t scePlayGoInitialize(const ScePlayGoInitParams* init) {
LOG_INFO(L"bufAddr:0x%08llx bufSize:0x%08x", (uint64_t)init->bufAddr, init->bufSize);
return Ok;
}
EXPORT SYSV_ABI int32_t scePlayGoTerminate(void) {
return Ok;
}
EXPORT SYSV_ABI int32_t scePlayGoOpen(ScePlayGoHandle* outHandle, const void* param) {
LOG_USE_MODULE(libScePlayGo);
*outHandle = 1;
@ -33,9 +34,11 @@ EXPORT SYSV_ABI int32_t scePlayGoOpen(ScePlayGoHandle* outHandle, const void* pa
return Ok;
}
EXPORT SYSV_ABI int32_t scePlayGoClose(ScePlayGoHandle handle) {
return Ok;
}
EXPORT SYSV_ABI int32_t scePlayGoGetLocus(ScePlayGoHandle handle, const ScePlayGoChunkId* chunkIds, uint32_t numberOfEntries, ScePlayGoLocus* outLoci) {
LOG_USE_MODULE(libScePlayGo);
for (uint32_t i = 0; i < numberOfEntries; i++) {
@ -50,62 +53,74 @@ EXPORT SYSV_ABI int32_t scePlayGoGetLocus(ScePlayGoHandle handle, const ScePlayG
return Ok;
}
EXPORT SYSV_ABI int32_t scePlayGoSetToDoList(ScePlayGoHandle handle, const ScePlayGoToDo* todoList, uint32_t numberOfEntries) {
LOG_USE_MODULE(libScePlayGo);
LOG_ERR(L"TODO: %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t scePlayGoGetToDoList(ScePlayGoHandle handle, ScePlayGoToDo* outTodoList, uint32_t numberOfEntries, uint32_t* outEntries) {
LOG_USE_MODULE(libScePlayGo);
LOG_ERR(L"TODO: %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t scePlayGoPrefetch(ScePlayGoHandle handle, const ScePlayGoChunkId* chunkIds, uint32_t numberOfEntries, ScePlayGoLocus minimumLocus) {
LOG_USE_MODULE(libScePlayGo);
LOG_ERR(L"TODO: %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t scePlayGoGetEta(ScePlayGoHandle handle, const ScePlayGoChunkId* chunkIds, uint32_t numberOfEntries, ScePlayGoEta* outEta) {
LOG_USE_MODULE(libScePlayGo);
LOG_ERR(L"TODO: %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t scePlayGoSetInstallSpeed(ScePlayGoHandle handle, ScePlayGoInstallSpeed speed) {
LOG_USE_MODULE(libScePlayGo);
LOG_ERR(L"TODO: %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t scePlayGoGetInstallSpeed(ScePlayGoHandle handle, ScePlayGoInstallSpeed* speed) {
LOG_USE_MODULE(libScePlayGo);
LOG_ERR(L"TODO: %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t scePlayGoSetLanguageMask(ScePlayGoHandle handle, ScePlayGoLanguageMask languageMask) {
LOG_USE_MODULE(libScePlayGo);
LOG_ERR(L"TODO: %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t scePlayGoGetLanguageMask(ScePlayGoHandle handle, ScePlayGoLanguageMask* outLanguageMask) {
LOG_USE_MODULE(libScePlayGo);
LOG_ERR(L"TODO: %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t scePlayGoGetProgress(ScePlayGoHandle handle, const ScePlayGoChunkId* chunkIds, uint32_t numberOfEntries,
ScePlayGoProgress* outProgress) {
LOG_USE_MODULE(libScePlayGo);
LOG_ERR(L"TODO: %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t scePlayGoGetChunkId(ScePlayGoHandle handle, ScePlayGoChunkId* outChunkIdList, uint32_t numberOfEntries, uint32_t* outEntries) {
LOG_USE_MODULE(libScePlayGo);
LOG_ERR(L"TODO: %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceDbgPlayGoRequestNextChunk(ScePlayGoHandle handle, const void* reserved) {
LOG_USE_MODULE(libScePlayGo);
LOG_ERR(L"TODO: %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceDbgPlayGoSnapshot(ScePlayGoHandle handle, const char* filename) {
LOG_USE_MODULE(libScePlayGo);
LOG_ERR(L"TODO: %S", __FUNCTION__);

8
modules/libSceRemoteplay/entry.cpp
View File

@ -1,8 +1,7 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceRemoteplay);
namespace {} // namespace
@ -16,26 +15,31 @@ EXPORT SYSV_ABI int sceRemoteplayInitialize(void* pHeap, size_t heapSize) {
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceRemoteplayTerminate() {
LOG_USE_MODULE(libSceRemoteplay);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceRemoteplayProhibit() {
LOG_USE_MODULE(libSceRemoteplay);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceRemoteplayApprove() {
LOG_USE_MODULE(libSceRemoteplay);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceRemoteplayProhibitStreaming(SceRemoteplayStreamingProhibition mode) {
LOG_USE_MODULE(libSceRemoteplay);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int sceRemoteplayGetConnectionStatus(SceUserServiceUserId userid, SceRemoteplayConnectionStatus* pStatus) {
*pStatus = SceRemoteplayConnectionStatus::Disconnect;
LOG_USE_MODULE(libSceRemoteplay);

24
modules/libSceSaveData/entry.cpp
View File

@ -1,9 +1,9 @@
#include "codes.h"
#include "common.h"
#include "logging.h"
#include "types.h"
#include <fileManager.h>
#include <logging.h>
LOG_DEFINE_MODULE(libSceSaveData);
@ -95,16 +95,19 @@ EXPORT SYSV_ABI int32_t sceSaveDataInitialize(const SceSaveDataInitParams3* init
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataInitialize2(const SceSaveDataInitParams3* initParam) {
LOG_USE_MODULE(libSceSaveData);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataInitialize3(const SceSaveDataInitParams3* initParam) {
LOG_USE_MODULE(libSceSaveData);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataTerminate() {
LOG_USE_MODULE(libSceSaveData);
LOG_ERR(L"todo %S", __FUNCTION__);
@ -124,6 +127,7 @@ EXPORT SYSV_ABI int32_t sceSaveDataTransferringMount(const SceSaveDataTransferri
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataUmount(const SceSaveDataMountPoint* mountPoint) {
std::string_view path(&mountPoint->data[0]);
@ -140,11 +144,13 @@ EXPORT SYSV_ABI int32_t sceSaveDataUmount(const SceSaveDataMountPoint* mountPoin
}
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataUmountWithBackup(const SceSaveDataMountPoint* mountPoint) {
LOG_USE_MODULE(libSceSaveData);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataGetMountInfo(const SceSaveDataMountPoint* mountPoint, SceSaveDataMountInfo* info) {
info->blocks = 100000;
info->freeBlocks = 100000;
@ -152,16 +158,19 @@ EXPORT SYSV_ABI int32_t sceSaveDataGetMountInfo(const SceSaveDataMountPoint* mou
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataDelete(const SceSaveDataDelete* del) {
LOG_USE_MODULE(libSceSaveData);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataDirNameSearch(const SceSaveDataDirNameSearchCond* cond, SceSaveDataDirNameSearchResult* result) {
LOG_USE_MODULE(libSceSaveData);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataSetParam(const SceSaveDataMountPoint* mountPoint, SceSaveDataParamType paramType, const void* paramBuf,
size_t paramBufSize) {
LOG_USE_MODULE(libSceSaveData);
@ -177,68 +186,81 @@ EXPORT SYSV_ABI int32_t sceSaveDataSetParam(const SceSaveDataMountPoint* mountPo
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataGetParam(const SceSaveDataMountPoint* mountPoint, SceSaveDataParamType paramType, void* paramBuf, size_t paramBufSize,
size_t* gotSize) {
LOG_USE_MODULE(libSceSaveData);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataSaveIcon(const SceSaveDataMountPoint* mountPoint, const SceSaveDataIcon* icon) {
LOG_USE_MODULE(libSceSaveData);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataLoadIcon(const SceSaveDataMountPoint* mountPoint, SceSaveDataIcon* icon) {
LOG_USE_MODULE(libSceSaveData);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataSyncSaveDataMemory(const SceSaveDataMemorySync* syncParam) {
LOG_USE_MODULE(libSceSaveData);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataSetupSaveDataMemory2(const SceSaveDataMemorySetup2* setupParam, SceSaveDataMemorySetupResult* result) {
LOG_USE_MODULE(libSceSaveData);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataGetSaveDataMemory2(SceSaveDataMemoryGet2* getParam) {
LOG_USE_MODULE(libSceSaveData);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataSetSaveDataMemory2(const SceSaveDataMemorySet2* setParam) {
LOG_USE_MODULE(libSceSaveData);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataRestoreBackupData(const SceSaveDataRestoreBackupData* restore) {
LOG_USE_MODULE(libSceSaveData);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataCheckBackupData(const SceSaveDataCheckBackupData* check) {
LOG_USE_MODULE(libSceSaveData);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataBackup(const SceSaveDataBackup* backup) {
LOG_USE_MODULE(libSceSaveData);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataGetProgress(float* progress) {
LOG_USE_MODULE(libSceSaveData);
LOG_DEBUG(L"todo %S", __FUNCTION__);
*progress = 1.0f;
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataClearProgress(void) {
LOG_USE_MODULE(libSceSaveData);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSaveDataGetEventResult(const SceSaveDataEventParam* eventParam, SceSaveDataEvent* event) {
LOG_USE_MODULE(libSceSaveData);
LOG_ERR(L"todo %S", __FUNCTION__);

3
modules/libSceSaveDataDialog/entry.cpp
View File

@ -1,9 +1,8 @@
#include "codes.h"
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceSaveDataDialog);
namespace {

3
modules/libSceScreenShot/entry.cpp
View File

@ -1,8 +1,7 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceScreenShot);
namespace {} // namespace

18
modules/libSceSsl/entry.cpp
View File

@ -1,19 +1,20 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceSsl);
namespace {} // namespace
extern "C" {
EXPORT const char* MODULE_NAME = "libSceSsl";
EXPORT const char* MODULE_NAME = "libSceSsl";
EXPORT SYSV_ABI int sceSslInit(size_t poolSize) {
static int id = 0;
return ++id;
}
EXPORT SYSV_ABI int sceSslTerm(int libsslCtxId) {
return Ok;
}
@ -21,37 +22,48 @@ EXPORT SYSV_ABI int sceSslTerm(int libsslCtxId) {
EXPORT SYSV_ABI int sceSslGetMemoryPoolStats(int libsslCtxId, SceSslMemoryPoolStats* currentStat) {
return Ok;
}
EXPORT SYSV_ABI int sceSslGetCaList(int libsslCtxId, SceSslCaList* caList) {
return Ok;
}
EXPORT SYSV_ABI int sceSslFreeCaList(int libsslCtxId, SceSslCaList* caList) {
return Ok;
}
EXPORT SYSV_ABI SceSslCertName* sceSslGetSubjectName(int libsslCtxId, SceSslCert* sslCert) {
return nullptr;
}
SceSslCertName* sceSslGetIssuerName(int libsslCtxId, SceSslCert* sslCert) {
return nullptr;
}
EXPORT SYSV_ABI int sceSslGetNotAfter(int libsslCtxId, SceSslCert* sslCert, uint64_t* limit) {
return Ok;
}
EXPORT SYSV_ABI int sceSslGetNotBefore(int libsslCtxId, SceSslCert* sslCert, uint64_t* begin) {
return Ok;
}
EXPORT SYSV_ABI int sceSslGetNameEntryCount(int libsslCtxId, const SceSslCertName* certName) {
return Ok;
}
EXPORT SYSV_ABI int sceSslGetNameEntryInfo(int libsslCtxId, const SceSslCertName* certName, int entryNum, char* oidname, size_t maxOidnameLen, uint8_t* value,
size_t maxValueLen, size_t* valueLen) {
return Ok;
}
EXPORT SYSV_ABI int sceSslFreeSslCertName(int libsslCtxId, SceSslCertName* certName) {
return Ok;
}
EXPORT SYSV_ABI int sceSslGetSerialNumber(int libsslCtxId, SceSslCert* sslCert, uint8_t* sboData, size_t* sboLen) {
return Ok;
}
EXPORT SYSV_ABI int sceSslGetCaCerts(int libsslCtxId, SceSslCaCerts* caCerts) {
return Ok;
}

5
modules/libSceSysmodule/entry.cpp
View File

@ -1,8 +1,7 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceSysmodule);
namespace {} // namespace
@ -16,11 +15,13 @@ EXPORT SYSV_ABI int sceSysmoduleLoadModule(uint16_t id) {
LOG_DEBUG(L"id = 0x%lx", id);
return Ok;
}
EXPORT SYSV_ABI int sceSysmoduleUnloadModule(uint16_t id) {
LOG_USE_MODULE(libSceSysmodule);
LOG_DEBUG(L"id = 0x%lx", id);
return Ok;
}
EXPORT SYSV_ABI int sceSysmoduleIsLoaded(uint16_t id) {
LOG_USE_MODULE(libSceSysmodule);
LOG_DEBUG(L"id = 0x%lx", id);

29
modules/libSceSystemService/entry.cpp
View File

@ -1,9 +1,9 @@
#include "common.h"
#include "logging.h"
#include "system_param.h"
#include "types.h"
#include <chrono>
#include <logging.h>
LOG_DEFINE_MODULE(libSceSystemService);
@ -37,6 +37,7 @@ bool is24HourFormat() {
// Check if the hours value is less than 13
return info.tm_hour >= 13;
}
SystemParamDateFormat getDateFormat() {
std::time_get<char>::dateorder order = std::use_facet<std::time_get<char>>(std::locale("")).date_order();
@ -74,16 +75,19 @@ EXPORT SYSV_ABI int32_t sceSystemServiceParamGetInt(SceSystemServiceParamId para
LOG_INFO(L" %d = %d", paramId, *value);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceParamGetString(SceSystemServiceParamId paramId, char* buf, size_t bufSize) {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceReceiveEvent(SceSystemServiceEvent* event) {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceGetStatus(SceSystemServiceStatus* status) {
LOG_USE_MODULE(libSceSystemService);
LOG_TRACE(L"todo %S", __FUNCTION__);
@ -95,32 +99,39 @@ EXPORT SYSV_ABI int32_t sceSystemServiceGetStatus(SceSystemServiceStatus* status
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceLoadExec(const char* path, char* const argv[]) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceHideSplashScreen() {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceDisableMusicPlayer() {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceReenableMusicPlayer() {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceSetGpuLoadEmulationMode(SceSystemServiceGpuLoadEmulationMode mode) {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI SceSystemServiceGpuLoadEmulationMode sceSystemServiceGetGpuLoadEmulationMode() {
return SceSystemServiceGpuLoadEmulationMode::NORMAL;
}
EXPORT SYSV_ABI int32_t sceSystemServiceGetDisplaySafeAreaInfo(SceSystemServiceDisplaySafeAreaInfo* info) {
if (info == nullptr) {
return Err::SERVICE_ERROR_PARAMETER;
@ -132,36 +143,43 @@ EXPORT SYSV_ABI int32_t sceSystemServiceGetDisplaySafeAreaInfo(SceSystemServiceD
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceLaunchWebBrowser(const char* uri, const SceSystemServiceLaunchWebBrowserParam* param) {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceLaunchEventDetails(int32_t userId, const char* eventId) {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceLaunchTournamentsTeamProfile(int32_t userId, const char* teamId, const char* eventId, const char* teamPlatform) {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceLaunchTournamentList(int32_t userId) {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServicePowerTick() {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceEnableSuspendConfirmationDialog() {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceDisableSuspendConfirmationDialog() {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
@ -169,36 +187,43 @@ EXPORT SYSV_ABI int32_t sceSystemServiceDisableSuspendConfirmationDialog() {
}
typedef struct SceSystemServiceAbnormalTerminationInfo SceSystemServiceAbnormalTerminationInfo;
EXPORT SYSV_ABI int32_t sceSystemServiceReportAbnormalTermination(const SceSystemServiceAbnormalTerminationInfo* info) {
EXPORT SYSV_ABI int32_t sceSystemServiceReportAbnormalTermination(const SceSystemServiceAbnormalTerminationInfo* info) {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceIsEyeToEyeDistanceAdjusted(int32_t userId, bool* isAdjusted) {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceShowEyeToEyeDistanceSetting() {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceDisablePersonalEyeToEyeDistanceSetting() {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceEnablePersonalEyeToEyeDistanceSetting() {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceShowControllerSettings() {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);
return Ok;
}
EXPORT SYSV_ABI int32_t sceSystemServiceGetHdrToneMapLuminance(SceSystemServiceHdrToneMapLuminance* hdrToneMapLuminance) {
LOG_USE_MODULE(libSceSystemService);
LOG_ERR(L"todo %S", __FUNCTION__);

3
modules/libSceUserService/entry.cpp
View File

@ -1,7 +1,6 @@
#include "common.h"
#include "errorcodes.h"
#include <logging.h>
#include "logging.h"
LOG_DEFINE_MODULE(libSceUserService);

2
modules/libSceVideoOut/entry.cpp
View File

@ -1,8 +1,8 @@
#include "common.h"
#include "core/kernel/eventqueue_types.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
#include <videoOut.h>
LOG_DEFINE_MODULE(libSceVideoOut);

21
modules/libSceVoiceQoS/entry.cpp
View File

@ -1,8 +1,7 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libSceVoiceQoS);
namespace {} // namespace
@ -14,63 +13,81 @@ EXPORT const char* MODULE_NAME = "libSceVoiceQoS";
EXPORT SYSV_ABI int32_t sceVoiceQoSInit(void* pMemBlock, uint32_t memSize, int32_t appType) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceVoiceQoSEnd(void) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceVoiceQoSCreateLocalEndpoint(SceVoiceQoSLocalId* pLocalId, int32_t userId, int32_t deviceInId, int32_t deviceOutId) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceVoiceQoSDeleteLocalEndpoint(SceVoiceQoSLocalId localId) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceVoiceQoSCreateRemoteEndpoint(SceVoiceQoSRemoteId* pRemoteId) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceVoiceQoSDeleteRemoteEndpoint(SceVoiceQoSRemoteId remoteId) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceVoiceQoSConnect(SceVoiceQoSConnectionId* pConnectionId, SceVoiceQoSLocalId localId, SceVoiceQoSRemoteId remoteId) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceVoiceQoSDisconnect(SceVoiceQoSConnectionId connectionId) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceVoiceQoSGetLocalEndpoint(SceVoiceQoSConnectionId connectionId, SceVoiceQoSLocalId* pLocalId) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceVoiceQoSGetRemoteEndpoint(SceVoiceQoSConnectionId connectionId, SceVoiceQoSRemoteId* pRemoteId) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceVoiceQoSSetLocalEndpointAttribute(SceVoiceQoSLocalId localId, SceVoiceQoSAttributeId attributeId, const void* pAttributeValue,
int attributeSize) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceVoiceQoSGetLocalEndpointAttribute(SceVoiceQoSLocalId localId, SceVoiceQoSAttributeId attributeId, void* pAttributeValue,
int attributeSize) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceVoiceQoSSetRemoteEndpointAttribute(SceVoiceQoSRemoteId remoteId, SceVoiceQoSAttributeId attributeId, const void* pAttributeValue,
int attributeSize) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceVoiceQoSGetRemoteEndpointAttribute(SceVoiceQoSRemoteId remoteId, SceVoiceQoSAttributeId attributeId, const void* pAttributeValue,
int attributeSize) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceVoiceQoSSetConnectionAttribute(SceVoiceQoSConnectionId connectionId, SceVoiceQoSAttributeId attributeId, const void* pAttributeValue,
int attributeSize) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceVoiceQoSGetConnectionAttribute(SceVoiceQoSConnectionId connectionId, SceVoiceQoSAttributeId attributeId, void* pAttributeValue,
int attributeSize) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceVoiceQoSGetStatus(SceVoiceQoSConnectionId connectionId, SceVoiceQoSStatusId statusId, void* pStatusValue, int statusSize) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceVoiceQoSWritePacket(SceVoiceQoSConnectionId connectionId, const void* pData, unsigned int* pSize) {
return Ok;
}
EXPORT SYSV_ABI int32_t sceVoiceQoSReadPacket(SceVoiceQoSConnectionId connectionId, void* pData, unsigned int* pSize) {
return Ok;
}

3
modules/libkernel/entry.cpp
View File

@ -1,8 +1,7 @@
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(libkernel);
namespace {} // namespace

2
modules/libkernel/equeue.cpp
View File

@ -1,8 +1,8 @@
#include "common.h"
#include "core/kernel/eventqueue.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(equeue);

2
modules/libkernel/eventflag.cpp
View File

@ -1,9 +1,9 @@
#include "core/kernel/eventflag.h"
#include "common.h"
#include "logging.h"
#include "types.h"
#include <logging.h>
LOG_DEFINE_MODULE(eventFlag);
using namespace Kernel::EventFlag;

2
modules/setupModule.cmake
View File

@ -2,6 +2,6 @@ function(setupModule _Target)
add_custom_command(TARGET ${_Target} POST_BUILD
COMMAND ${CMAKE_INSTALL_PREFIX}/development/bin/dll2Nids.exe ${CMAKE_CURRENT_BINARY_DIR}/${_Target}.dll
)
add_dependencies(${_Target} logging)
install(FILES $<TARGET_PDB_FILE:${_Target}> DESTINATION debug OPTIONAL)
endfunction()

3
modules/template/entry.cpp
View File

@ -1,8 +1,7 @@
#include "common.h"
#include <logging.h>
#include "logging.h"
#include "types.h"
LOG_DEFINE_MODULE(libSce);
namespace {} // namespace

23
tools/logging/CMakeLists.txt Normal file
View File

@ -0,0 +1,23 @@
cmake_minimum_required(VERSION 3.24)
add_library(logging SHARED logging.cpp)
target_link_directories(logging PRIVATE
${CMAKE_BINARY_DIR}/third_party/install/lib
)
add_dependencies(logging third_party)
target_link_libraries(logging ws2_32 p7)
target_include_directories(logging PRIVATE ${CMAKE_SOURCE_DIR}/third_party/p7/Headers)
target_compile_options(logging PRIVATE "/Zi")
ADD_CUSTOM_COMMAND(TARGET logging
POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_BINARY_DIR}/logging.lib" "${CMAKE_BINARY_DIR}/third_party/install/lib/"
)
set_target_properties(logging
PROPERTIES
LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/."
)

82
tools/logging/logging.cpp Normal file
View File

@ -0,0 +1,82 @@
#define __APICALL_EXTERN
#include "logging.h"
#undef __APICALL_EXTERN
#include <P7_Telemetry.h>
#include <P7_Trace.h>
#include <cassert>
#include <chrono>
#include <mutex>
#include <unordered_map>
namespace __Log {
IP7_Client** getClient() {
static IP7_Client* mClient = nullptr;
return &mClient;
}
IP7_Trace** getTrace() {
static IP7_Trace* mTrace = nullptr;
return &mTrace;
}
std::unordered_map<std::wstring, int>& getThreads() {
static std::unordered_map<std::wstring, int> mThreads;
return mThreads;
}
std::mutex& getMutex() {
static std::mutex mMutex;
return mMutex;
}
void* __registerLoggingModule(std::wstring&& name) {
auto trace = getTrace();
{
const std::unique_lock lock(getMutex());
if (*getClient() == nullptr) {
*getClient() = P7_Create_Client(TM("/P7.Pool=1024"));
*trace = P7_Create_Trace(*getClient(), __APPNAME);
P7_Set_Crash_Handler();
}
}
IP7_Trace::hModule pModule;
(*trace)->Register_Module(name.data(), &pModule);
(*trace)->Set_Verbosity(pModule, eP7Trace_Level::EP7TRACE_LEVEL_DEBUG);
return pModule;
}
void deinit() {
P7_Client_Flush(*getClient());
}
uint8_t isIgnored(void* module, eTrace_Level level) {
return static_cast<uint8_t>((*getTrace())->Get_Verbosity(module)) <= static_cast<typename std::underlying_type<__Log::eTrace_Level>::type>(level);
}
void __log(eTrace_Level level, void* hmodule, unsigned short i_wLine, const char* i_pFile, const char* i_pFunction, const wchar_t* i_pFormat, ...) {
// EXIT_IF(mTrace == nullptr);
va_list args = nullptr;
va_start(args, i_pFormat);
if (static_cast<typename std::underlying_type<__Log::eTrace_Level>::type>(level) >=
static_cast<typename std::underlying_type<__Log::eTrace_Level>::type>(eTrace_Level::err)) {
vwprintf(i_pFormat, args);
printf("\n");
}
(*getTrace())
->Trace_Embedded(0, static_cast<eP7Trace_Level>(static_cast<typename std::underlying_type<__Log::eTrace_Level>::type>(level)), hmodule, i_wLine, i_pFile,
i_pFunction, &i_pFormat, &args);
va_end(args);
if (level == eTrace_Level::crit) {
P7_Exceptional_Flush();
std::this_thread::sleep_for(std::chrono::milliseconds(500));
// while (!::IsDebuggerPresent())
//::Sleep(100); // to avoid 100% CPU load
exit(1);
}
}
} // namespace __Log

66
tools/logging/logging.h Normal file
View File

@ -0,0 +1,66 @@
#pragma once
#ifdef LOGGING_DUMMY
#include "logging_dummy.h"
#else
#ifdef __APICALL_EXTERN
#define __APICALL __declspec(dllexport)
#else
#define __APICALL __declspec(dllimport)
#endif
#include <string>
namespace __Log {
constexpr wchar_t const* __APPNAME = L"psOff";
__APICALL void* __registerLoggingModule(std::wstring&& name); // For internal usage
enum class eTrace_Level : uint8_t {
trace = 0,
debug,
info,
warn,
err,
crit,
};
__APICALL void __log(eTrace_Level level, void* hmodule, unsigned short i_wLine, const char* i_pFile, const char* i_pFunction, const wchar_t* i_pFormat, ...);
/**
* @brief Call at end to flush messages
*
*/
__APICALL void deinit();
__APICALL uint8_t isIgnored(void* module, eTrace_Level level);
} // namespace __Log
/**
* @brief Call at start of file or in class
*
*/
#define LOG_DEFINE_MODULE(name) \
namespace { \
void* __TRACE_MODULE__DEFINED__##name = __Log::__registerLoggingModule(L#name); \
}
/**
* @brief Call before logging
*
*/
#define LOG_USE_MODULE(name) [[maybe_unused]] void* __TRACE_MODULE = __TRACE_MODULE__DEFINED__##name
#define LOG_GET_MODULE(name) __TRACE_MODULE__DEFINED__##name
// Logging
#define LOG_TRACE(...) __Log::__log(__Log::eTrace_Level::trace, __TRACE_MODULE, (unsigned short)__LINE__, __FILE__, __FUNCTION__, __VA_ARGS__)
#define LOG_DEBUG(...) __Log::__log(__Log::eTrace_Level::debug, __TRACE_MODULE, (unsigned short)__LINE__, __FILE__, __FUNCTION__, __VA_ARGS__)
#define LOG_INFO(...) __Log::__log(__Log::eTrace_Level::info, __TRACE_MODULE, (unsigned short)__LINE__, __FILE__, __FUNCTION__, __VA_ARGS__)
#define LOG_WARN(...) __Log::__log(__Log::eTrace_Level::warn, __TRACE_MODULE, (unsigned short)__LINE__, __FILE__, __FUNCTION__, __VA_ARGS__)
#define LOG_ERR(...) __Log::__log(__Log::eTrace_Level::err, __TRACE_MODULE, (unsigned short)__LINE__, __FILE__, __FUNCTION__, __VA_ARGS__)
#define LOG_CRIT(...) __Log::__log(__Log::eTrace_Level::crit, __TRACE_MODULE, (unsigned short)__LINE__, __FILE__, __FUNCTION__, __VA_ARGS__)
// -
#undef __APICALL
#endif

15
tools/logging/logging_dummy.cpp Normal file
View File

@ -0,0 +1,15 @@
#include "logging_dummy.h"
#include <stdarg.h>
void __Log::__log(bool doExit, const wchar_t* i_pFormat, ...) {
va_list args = nullptr;
va_start(args, i_pFormat);
vwprintf(i_pFormat, args);
printf("\n");
va_end(args);
if (doExit) exit(1);
}

57
tools/logging/logging_dummy.h Normal file
View File

@ -0,0 +1,57 @@
#pragma once
#include <string>
namespace __Log {
inline void* __registerModule(std::wstring&& name) {
return nullptr;
}
enum class eTrace_Level : uint8_t {
trace = 0,
debug,
info,
warn,
err,
crit,
};
void __log(bool doExit, const wchar_t* i_pFormat, ...);
/**
* @brief Call at end to flush messages
*
*/
constexpr void deinit() {}
/**
* @brief Register thread (for better logging)
*
* @param name
*/
constexpr uint8_t isIgnored(void* module, eTrace_Level level) {
return true;
}
} // namespace __Log
/**
* @brief Call at start of file or in class
*
*/
#define LOG_DEFINE_MODULE(name) void* __TRACE_MODULE__DEFINED__##name = __Log::__registerModule(L#name)
/**
* @brief Call before logging
*
*/
#define LOG_USE_MODULE(name) [[maybe_unused]] void* __TRACE_MODULE = __TRACE_MODULE__DEFINED__##name
#define LOG_GET_MODULE(name) __TRACE_MODULE__DEFINED__##name
// Logging
#define LOG_TRACE(...) /**/
#define LOG_DEBUG(...) /**/
#define LOG_INFO(...) /**/
#define LOG_WARN(...) /**/
#define LOG_ERR(...) __Log::__log(false, __VA_ARGS__)
#define LOG_CRIT(...) __Log::__log(true, __VA_ARGS__)
// -