feat(libs): add libs function signatures

core/libs/CMakeLists.txt

@@ -1,12 +1,12 @@
 add_executable(nid_patcher
-    ${CMAKE_CURRENT_SOURCE_DIR}/nid/src/Sha1.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/nid/src/NidCompute.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/nid/src/main.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/nid/src/Sha1.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/nid/src/NidCompute.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/nid/src/main.cpp
 )
 target_include_directories(nid_patcher PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/nid/include)
 target_compile_features(nid_patcher PRIVATE cxx_std_20)
 
-file(GLOB LIBS_DIRS LIST_DIRECTORIES true ${CMAKE_CURRENT_SOURCE_DIR}/lib*)
+file(GLOB LIBS_DIRS LIST_DIRECTORIES true ${CMAKE_CURRENT_SOURCE_DIR}/prx/*)
 
 set(PATCHED_STAMPS)
 
@@ -15,22 +15,23 @@ foreach(LIB_DIR ${LIBS_DIRS})
         get_filename_component(LIB_NAME ${LIB_DIR} NAME)
 
         add_library(${LIB_NAME} SHARED EXCLUDE_FROM_ALL ${LIB_DIR}/Export.cpp)
+        target_include_directories(${LIB_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
         set_target_properties(${LIB_NAME} PROPERTIES
-            PREFIX ""
-            SUFFIX .rpx
-            RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libs
-            LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libs
+                PREFIX ""
+                SUFFIX .rpx
+                RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libs
+                LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libs
         )
 
-        set(RPX_FILE ${CMAKE_CURRENT_BINARY_DIR}/libs/${LIB_NAME}.rpx)
+        set(RPX_FILE ${CMAKE_CURRENT_BINARY_DIR}/libs/${LIB_NAME}.prx)
         set(STAMP_FILE ${CMAKE_CURRENT_BINARY_DIR}/libs/${LIB_NAME}.patched)
 
         add_custom_command(
-            OUTPUT ${STAMP_FILE}
-            COMMAND $<TARGET_FILE:nid_patcher> ${LIB_NAME} ${RPX_FILE}
-            COMMAND ${CMAKE_COMMAND} -E touch ${STAMP_FILE}
-            DEPENDS nid_patcher ${LIB_NAME}
-            COMMENT "Patching NIDs for ${LIB_NAME}"
+                OUTPUT ${STAMP_FILE}
+                COMMAND $<TARGET_FILE:nid_patcher> ${LIB_NAME} ${RPX_FILE}
+                COMMAND ${CMAKE_COMMAND} -E touch ${STAMP_FILE}
+                DEPENDS nid_patcher ${LIB_NAME}
+                COMMENT "Patching NIDs for ${LIB_NAME}"
         )
 
         list(APPEND PATCHED_STAMPS ${STAMP_FILE})

core/libs/prx/CMakeLists.txt

@@ -0,0 +1,40 @@
+add_executable(nid_patcher
+    ${CMAKE_CURRENT_SOURCE_DIR}/nid/src/Sha1.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/nid/src/NidCompute.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/nid/src/main.cpp
+)
+target_include_directories(nid_patcher PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/nid/include)
+target_compile_features(nid_patcher PRIVATE cxx_std_20)
+
+file(GLOB LIBS_DIRS LIST_DIRECTORIES true ${CMAKE_CURRENT_SOURCE_DIR}/lib*)
+
+set(PATCHED_STAMPS)
+
+foreach(LIB_DIR ${LIBS_DIRS})
+    if(IS_DIRECTORY ${LIB_DIR})
+        get_filename_component(LIB_NAME ${LIB_DIR} NAME)
+
+        add_library(${LIB_NAME} SHARED EXCLUDE_FROM_ALL ${LIB_DIR}/Export.cpp)
+        set_target_properties(${LIB_NAME} PROPERTIES
+            PREFIX ""
+            SUFFIX .rpx
+            RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libs
+            LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libs
+        )
+
+        set(RPX_FILE ${CMAKE_CURRENT_BINARY_DIR}/libs/${LIB_NAME}.prx)
+        set(STAMP_FILE ${CMAKE_CURRENT_BINARY_DIR}/libs/${LIB_NAME}.patched)
+
+        add_custom_command(
+            OUTPUT ${STAMP_FILE}
+            COMMAND $<TARGET_FILE:nid_patcher> ${LIB_NAME} ${RPX_FILE}
+            COMMAND ${CMAKE_COMMAND} -E touch ${STAMP_FILE}
+            DEPENDS nid_patcher ${LIB_NAME}
+            COMMENT "Patching NIDs for ${LIB_NAME}"
+        )
+
+        list(APPEND PATCHED_STAMPS ${STAMP_FILE})
+    endif()
+endforeach()
+
+add_custom_target(libs DEPENDS ${PATCHED_STAMPS})

core/libs/prx/libReactNative.Modules.Vsh.WebAppLauncher/Export.cpp

@@ -0,0 +1,46 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int ErrorDialogClose(void) {
+ return 0;
+}
+
+int ErrorDialogOpen(const void* param) {
+ (void)param;
+ return 0;
+}
+
+int ShareGetCurrentStatus(uint32_t feature_flag, ShareCurrentStatus* status) {
+ (void)feature_flag;
+ (void)status;
+ return 0;
+}
+
+int ShareInitialize(size_t heap_size, int thread_priority, uint64_t affinity_mask) {
+ (void)heap_size;
+ (void)thread_priority;
+ (void)affinity_mask;
+ return 0;
+}
+
+int ShareTerminate(void) {
+ return 0;
+}
+
+int SystemServiceParamGetInt(int param_id, int* value) {
+ (void)param_id;
+ (void)value;
+ return 0;
+}
+
+int SystemServiceParamGetString(int param_id, char* buf, size_t buf_size) {
+ (void)param_id;
+ (void)buf;
+ (void)buf_size;
+ return 0;
+}
+
+}

core/libs/prx/libReactNative.Modules.Vsh/Export.cpp

@@ -0,0 +1,30 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int RemotePlayGetConnectionStatus(int user_id, int* status) {
+ (void)user_id;
+ (void)status;
+ return 0;
+}
+
+int ShareGetCurrentStatus(uint32_t feature_flag, ShareCurrentStatus* status) {
+ (void)feature_flag;
+ (void)status;
+ return 0;
+}
+
+int ShareInitialize(size_t heap_size, int thread_priority, uint64_t affinity_mask) {
+ (void)heap_size;
+ (void)thread_priority;
+ (void)affinity_mask;
+ return 0;
+}
+
+int ShareTerminate(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceAcm/Export.cpp

@@ -0,0 +1,42 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceAcmBatchStartBuffer(AcmContextId context, const void* batch_commands, size_t batch_size, AcmBatchError* batch_error, AcmBatchId* batch) {
+ (void)context;
+ (void)batch_commands;
+ (void)batch_size;
+ (void)batch_error;
+ (void)batch;
+ return 0;
+}
+
+int sceAcmBatchStartBuffers(AcmContextId context, uint32_t batch_info_count, const AcmBatchInfo* const batch_info[], AcmBatchError* batch_error, AcmBatchId* batch) {
+ (void)context;
+ (void)batch_info_count;
+ (void)batch_info;
+ (void)batch_error;
+ (void)batch;
+ return 0;
+}
+
+int sceAcmBatchWait(AcmContextId context, AcmBatchId batch, uint32_t timeout) {
+ (void)context;
+ (void)batch;
+ (void)timeout;
+ return 0;
+}
+
+int sceAcmContextCreate(AcmContextId* context) {
+ (void)context;
+ return 0;
+}
+
+int sceAcmContextDestroy(AcmContextId context) {
+ (void)context;
+ return 0;
+}
+
+}

core/libs/prx/libSceAgc/Export.cpp

@@ -0,0 +1,780 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+uint32_t* sceAgcAcbAcquireMem(CommandBuffer* buf, uint32_t gcr_cntl, const volatile void* base, uint64_t size_bytes, uint32_t poll_cycles) {
+ (void)buf;
+ (void)gcr_cntl;
+ (void)base;
+ (void)size_bytes;
+ (void)poll_cycles;
+ return nullptr;
+}
+
+uint32_t sceAgcAcbAcquireMemGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcAcbCondExec(CommandBuffer* buf, const volatile uint32_t* address, uint32_t num_dwords) {
+ (void)buf;
+ (void)address;
+ (void)num_dwords;
+ return nullptr;
+}
+
+uint32_t sceAgcAcbCondExecGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcAcbCopyData(CommandBuffer* buf, uint8_t dst, uint8_t dst_cache_policy, uint64_t dst_address, uint8_t src, uint8_t src_cache_policy, uint64_t src_address_or_immediate, uint8_t item_size, uint8_t write_confirm) {
+ (void)buf;
+ (void)dst;
+ (void)dst_cache_policy;
+ (void)dst_address;
+ (void)src;
+ (void)src_cache_policy;
+ (void)src_address_or_immediate;
+ (void)item_size;
+ (void)write_confirm;
+ return nullptr;
+}
+
+uint32_t* sceAgcAcbDispatchIndirect(CommandBuffer* buf, const volatile void* indirect_args, uint32_t modifier) {
+ (void)buf;
+ (void)indirect_args;
+ (void)modifier;
+ return nullptr;
+}
+
+uint32_t* sceAgcAcbDmaData(CommandBuffer* buf, uint8_t dst, uint8_t dst_cache_policy, uint64_t dst_address_or_offset, uint8_t src, uint8_t src_cache_policy, uint64_t src_address_or_offset_or_immediate, uint32_t num_bytes, uint8_t wait_for_previous, uint8_t write_confirm) {
+ (void)buf;
+ (void)dst;
+ (void)dst_cache_policy;
+ (void)dst_address_or_offset;
+ (void)src;
+ (void)src_cache_policy;
+ (void)src_address_or_offset_or_immediate;
+ (void)num_bytes;
+ (void)wait_for_previous;
+ (void)write_confirm;
+ return nullptr;
+}
+
+uint32_t* sceAgcAcbEventWrite(CommandBuffer* buf, uint8_t event_type, const volatile void* address) {
+ (void)buf;
+ (void)event_type;
+ (void)address;
+ return nullptr;
+}
+
+uint32_t sceAgcAcbJumpGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcAcbPopMarker(CommandBuffer* buf) {
+ (void)buf;
+ return nullptr;
+}
+
+uint32_t* sceAgcAcbPushMarker(CommandBuffer* buf, const char* str, uint32_t color) {
+ (void)buf;
+ (void)str;
+ (void)color;
+ return nullptr;
+}
+
+uint32_t* sceAgcAcbResetQueue(CommandBuffer* buf, uint32_t op) {
+ (void)buf;
+ (void)op;
+ return nullptr;
+}
+
+uint32_t* sceAgcAcbSetMarker(CommandBuffer* buf, const char* str, uint32_t color) {
+ (void)buf;
+ (void)str;
+ (void)color;
+ return nullptr;
+}
+
+uint32_t* sceAgcAcbWaitRegMem(CommandBuffer* buf, uint8_t size, uint8_t compare_function, uint8_t cache_policy, const volatile void* address, uint64_t reference, uint64_t mask, uint32_t poll_cycles) {
+ (void)buf;
+ (void)size;
+ (void)compare_function;
+ (void)cache_policy;
+ (void)address;
+ (void)reference;
+ (void)mask;
+ (void)poll_cycles;
+ return nullptr;
+}
+
+uint32_t* sceAgcAcbWriteData(CommandBuffer* buf, uint8_t dst, uint8_t cache_policy, uint64_t address_or_offset, const void* data, uint32_t num_dwords, uint8_t increment, uint8_t write_confirm) {
+ (void)buf;
+ (void)dst;
+ (void)cache_policy;
+ (void)address_or_offset;
+ (void)data;
+ (void)num_dwords;
+ (void)increment;
+ (void)write_confirm;
+ return nullptr;
+}
+
+uint32_t* sceAgcCbBranch(CommandBuffer* buf, uint8_t mode, uint8_t compare_function, const volatile uint64_t* compare_addr, uint64_t mask, uint64_t reference, uint8_t cache_policy1, const volatile uint32_t* buffer1, uint32_t size_in_dwords1, uint8_t cache_policy2, const volatile uint32_t* buffer2, uint32_t size_in_dwords2) {
+ (void)buf;
+ (void)mode;
+ (void)compare_function;
+ (void)compare_addr;
+ (void)mask;
+ (void)reference;
+ (void)cache_policy1;
+ (void)buffer1;
+ (void)size_in_dwords1;
+ (void)cache_policy2;
+ (void)buffer2;
+ (void)size_in_dwords2;
+ return nullptr;
+}
+
+uint32_t* sceAgcCbDispatch(CommandBuffer* buf, uint32_t thread_group_x, uint32_t thread_group_y, uint32_t thread_group_z, uint32_t modifier) {
+ (void)buf;
+ (void)thread_group_x;
+ (void)thread_group_y;
+ (void)thread_group_z;
+ (void)modifier;
+ return nullptr;
+}
+
+uint32_t sceAgcCbDispatchGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcCbNop(CommandBuffer* buf, uint32_t size_in_dwords) {
+ (void)buf;
+ (void)size_in_dwords;
+ return nullptr;
+}
+
+uint32_t sceAgcCbNopGetSize(uint32_t size_in_dwords) {
+ (void)size_in_dwords;
+ return 0;
+}
+
+uint32_t sceAgcCbQueueEndOfPipeActionGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcCbReleaseMem(CommandBuffer* buf, uint8_t action, uint16_t gcr_cntl, uint8_t dst, uint8_t cache_policy, const volatile Label* address, uint8_t data_sel, uint64_t data, uint16_t gds_offset, uint16_t gds_size, uint8_t interrupt, uint32_t interrupt_ctx_id) {
+ (void)buf;
+ (void)action;
+ (void)gcr_cntl;
+ (void)dst;
+ (void)cache_policy;
+ (void)address;
+ (void)data_sel;
+ (void)data;
+ (void)gds_offset;
+ (void)gds_size;
+ (void)interrupt;
+ (void)interrupt_ctx_id;
+ return nullptr;
+}
+
+uint32_t* sceAgcCbSetShRegisterRangeDirect(CommandBuffer* buf, uint32_t offset, const uint32_t* values, uint32_t num_values) {
+ (void)buf;
+ (void)offset;
+ (void)values;
+ (void)num_values;
+ return nullptr;
+}
+
+uint32_t sceAgcCbSetShRegisterRangeDirectGetSize(uint32_t num_values) {
+ (void)num_values;
+ return 0;
+}
+
+uint32_t* sceAgcCbSetShRegistersDirect(CommandBuffer* buf, const volatile ShaderRegister* regs, uint32_t num_regs) {
+ (void)buf;
+ (void)regs;
+ (void)num_regs;
+ return nullptr;
+}
+
+int sceAgcCondExecPatchSetCommandAddress(uint32_t* cmd, const volatile uint32_t* command) {
+ (void)cmd;
+ (void)command;
+ return 0;
+}
+
+int sceAgcCondExecPatchSetEnd(uint32_t* cmd, const volatile uint32_t* buffer) {
+ (void)cmd;
+ (void)buffer;
+ return 0;
+}
+
+int sceAgcCreateInterpolantMapping(ShaderRegister* regs, const Shader* gs, const Shader* ps) {
+ (void)regs;
+ (void)gs;
+ (void)ps;
+ return 0;
+}
+
+int sceAgcCreatePrimState(ShaderRegister* cx_regs, ShaderRegister* uc_regs, const Shader* hs, const Shader* gs, uint32_t prim_type) {
+ (void)cx_regs;
+ (void)uc_regs;
+ (void)hs;
+ (void)gs;
+ (void)prim_type;
+ return 0;
+}
+
+int sceAgcCreateShader(Shader** dst, void* header, const volatile void* code) {
+ (void)dst;
+ (void)header;
+ (void)code;
+ return 0;
+}
+
+uint32_t* sceAgcDcbAcquireMem(CommandBuffer* buf, uint8_t engine, uint32_t cb_db_op, uint32_t gcr_cntl, const volatile void* base, uint64_t size_bytes, uint32_t poll_cycles) {
+ (void)buf;
+ (void)engine;
+ (void)cb_db_op;
+ (void)gcr_cntl;
+ (void)base;
+ (void)size_bytes;
+ (void)poll_cycles;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbAcquireMemGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbCondExec(CommandBuffer* buf, const volatile uint32_t* address, uint32_t num_dwords) {
+ (void)buf;
+ (void)address;
+ (void)num_dwords;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbCondExecGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbContextStateOp(CommandBuffer* buf, uint32_t operation) {
+ (void)buf;
+ (void)operation;
+ return nullptr;
+}
+
+uint64_t sceAgcDcbContextStateOpGetSize(uint32_t operation) {
+ (void)operation;
+ return 0;
+}
+
+uint32_t* sceAgcDcbCopyData(CommandBuffer* buf, uint8_t dst, uint8_t dst_cache_policy, uint64_t dst_address, uint8_t src, uint8_t src_cache_policy, uint64_t src_address_or_immediate, uint8_t item_size, uint8_t write_confirm) {
+ (void)buf;
+ (void)dst;
+ (void)dst_cache_policy;
+ (void)dst_address;
+ (void)src;
+ (void)src_cache_policy;
+ (void)src_address_or_immediate;
+ (void)item_size;
+ (void)write_confirm;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbDispatchIndirect(CommandBuffer* buf, uint32_t data_offset_in_bytes, uint32_t flags) {
+ (void)buf;
+ (void)data_offset_in_bytes;
+ (void)flags;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbDispatchIndirectGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbDmaData(CommandBuffer* buf, uint8_t engine, uint8_t dst, uint8_t dst_cache_policy, uint64_t dst_address_or_offset, uint8_t src, uint8_t src_cache_policy, uint64_t src_address_or_offset_or_immediate, uint32_t num_bytes, uint8_t wait_for_previous, uint8_t write_confirm, uint8_t block_engine) {
+ (void)buf;
+ (void)engine;
+ (void)dst;
+ (void)dst_cache_policy;
+ (void)dst_address_or_offset;
+ (void)src;
+ (void)src_cache_policy;
+ (void)src_address_or_offset_or_immediate;
+ (void)num_bytes;
+ (void)wait_for_previous;
+ (void)write_confirm;
+ (void)block_engine;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbDrawIndex(CommandBuffer* buf, uint32_t index_count, const volatile void* index_addr, uint64_t modifier) {
+ (void)buf;
+ (void)index_count;
+ (void)index_addr;
+ (void)modifier;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbDrawIndexAuto(CommandBuffer* buf, uint32_t index_count, uint64_t modifier) {
+ (void)buf;
+ (void)index_count;
+ (void)modifier;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbDrawIndexAutoGetSize(void) {
+ return 0;
+}
+
+uint32_t sceAgcDcbDrawIndexGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbDrawIndexIndirect(CommandBuffer* buf, uint32_t data_offset_in_bytes, uint64_t modifier) {
+ (void)buf;
+ (void)data_offset_in_bytes;
+ (void)modifier;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbDrawIndexIndirectMulti(CommandBuffer* buf, uint32_t data_offset_in_bytes, uint32_t count_indirect, uint32_t max_count_or_count, const volatile void* count_addr, uint32_t stride_in_bytes, uint64_t modifier) {
+ (void)buf;
+ (void)data_offset_in_bytes;
+ (void)count_indirect;
+ (void)max_count_or_count;
+ (void)count_addr;
+ (void)stride_in_bytes;
+ (void)modifier;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbDrawIndexMultiInstanced(CommandBuffer* buf, uint32_t index_count, const volatile void* index_addr, const volatile void* object_ids, uint32_t instance_count, uint64_t modifier) {
+ (void)buf;
+ (void)index_count;
+ (void)index_addr;
+ (void)object_ids;
+ (void)instance_count;
+ (void)modifier;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbDrawIndexMultiInstancedGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbDrawIndexOffset(CommandBuffer* buf, uint32_t index_offset, uint32_t index_count, uint64_t modifier) {
+ (void)buf;
+ (void)index_offset;
+ (void)index_count;
+ (void)modifier;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbDrawIndexOffsetGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbDrawIndirect(CommandBuffer* buf, uint32_t data_offset_in_bytes, uint64_t modifier) {
+ (void)buf;
+ (void)data_offset_in_bytes;
+ (void)modifier;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbDrawIndirectGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbEventWrite(CommandBuffer* buf, uint8_t event_type, const volatile void* address) {
+ (void)buf;
+ (void)event_type;
+ (void)address;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbGetLodStats(CommandBuffer* buf, uint8_t cache_policy, const volatile void* buffer, uint32_t buffer_size_in_bytes, uint32_t reset_count, uint8_t force_reset, uint8_t report_and_reset, uint32_t reporting_interval_in_100k_clocks) {
+ (void)buf;
+ (void)cache_policy;
+ (void)buffer;
+ (void)buffer_size_in_bytes;
+ (void)reset_count;
+ (void)force_reset;
+ (void)report_and_reset;
+ (void)reporting_interval_in_100k_clocks;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbJump(CommandBuffer* buf, uint8_t mode, uint8_t cache_policy, const uint32_t* target, uint32_t size_in_dwords) {
+ (void)buf;
+ (void)mode;
+ (void)cache_policy;
+ (void)target;
+ (void)size_in_dwords;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbJumpGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbPopMarker(CommandBuffer* buf) {
+ (void)buf;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbPushMarker(CommandBuffer* buf, const char* str, uint32_t color) {
+ (void)buf;
+ (void)str;
+ (void)color;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbResetQueue(CommandBuffer* buf, uint32_t op, uint32_t state) {
+ (void)buf;
+ (void)op;
+ (void)state;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbRewind(CommandBuffer* buf, uint32_t initial_state) {
+ (void)buf;
+ (void)initial_state;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbRewindGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbSetBaseIndirectArgs(CommandBuffer* buf, uint32_t shader_type, const volatile void* indirect_base_addr) {
+ (void)buf;
+ (void)shader_type;
+ (void)indirect_base_addr;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetCxRegisterDirect(CommandBuffer* buf, ShaderRegister reg) {
+ (void)buf;
+ (void)reg;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbSetCxRegisterDirectGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbSetCxRegistersIndirect(CommandBuffer* buf, const volatile ShaderRegister* regs, uint32_t num_regs) {
+ (void)buf;
+ (void)regs;
+ (void)num_regs;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetFlip(CommandBuffer* buf, uint32_t video_out_handle, int32_t display_buffer_index, uint32_t flip_mode, int64_t flip_arg) {
+ (void)buf;
+ (void)video_out_handle;
+ (void)display_buffer_index;
+ (void)flip_mode;
+ (void)flip_arg;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetIndexBuffer(CommandBuffer* buf, uint64_t index_addr) {
+ (void)buf;
+ (void)index_addr;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetIndexCount(CommandBuffer* buf, uint32_t index_count) {
+ (void)buf;
+ (void)index_count;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetIndexSize(CommandBuffer* buf, uint8_t index_size, uint8_t cache_policy) {
+ (void)buf;
+ (void)index_size;
+ (void)cache_policy;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetMarker(CommandBuffer* buf, const char* str, uint32_t color) {
+ (void)buf;
+ (void)str;
+ (void)color;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetNumInstances(CommandBuffer* buf, uint32_t num_instances) {
+ (void)buf;
+ (void)num_instances;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbSetNumInstancesGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbSetPredication(CommandBuffer* buf, uint8_t condition, uint8_t op, uint8_t wait_op, const volatile void* address, uint32_t count_in_dwords) {
+ (void)buf;
+ (void)condition;
+ (void)op;
+ (void)wait_op;
+ (void)address;
+ (void)count_in_dwords;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetShRegisterDirect(CommandBuffer* buf, ShaderRegister reg) {
+ (void)buf;
+ (void)reg;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetShRegistersIndirect(CommandBuffer* buf, const volatile ShaderRegister* regs, uint32_t num_regs) {
+ (void)buf;
+ (void)regs;
+ (void)num_regs;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetUcRegisterDirect(CommandBuffer* buf, ShaderRegister reg) {
+ (void)buf;
+ (void)reg;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetUcRegistersIndirect(CommandBuffer* buf, const volatile ShaderRegister* regs, uint32_t num_regs) {
+ (void)buf;
+ (void)regs;
+ (void)num_regs;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetWorkloadComplete(CommandBuffer* buf, uint32_t stream_id, uint32_t workload_id) {
+ (void)buf;
+ (void)stream_id;
+ (void)workload_id;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetWorkloadsActive(CommandBuffer* buf, uint32_t stream_id, const uint32_t* workload_ids, uint32_t workload_count) {
+ (void)buf;
+ (void)stream_id;
+ (void)workload_ids;
+ (void)workload_count;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbStallCommandBufferParser(CommandBuffer* buf) {
+ (void)buf;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbWaitOnAddressGetSize(uint32_t size) {
+ (void)size;
+ return 0;
+}
+
+uint32_t* sceAgcDcbWaitRegMem(CommandBuffer* buf, uint8_t size, uint8_t compare_function, uint8_t op, uint8_t cache_policy, const volatile void* address, uint64_t reference, uint64_t mask, uint32_t poll_cycles) {
+ (void)buf;
+ (void)size;
+ (void)compare_function;
+ (void)op;
+ (void)cache_policy;
+ (void)address;
+ (void)reference;
+ (void)mask;
+ (void)poll_cycles;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbWaitUntilSafeForRendering(CommandBuffer* buf, uint32_t video_out_handle, uint32_t display_buffer_index) {
+ (void)buf;
+ (void)video_out_handle;
+ (void)display_buffer_index;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbWriteData(CommandBuffer* buf, uint8_t dst, uint8_t cache_policy, uint64_t address_or_offset, const void* data, uint32_t num_dwords, uint8_t increment, uint8_t write_confirm) {
+ (void)buf;
+ (void)dst;
+ (void)cache_policy;
+ (void)address_or_offset;
+ (void)data;
+ (void)num_dwords;
+ (void)increment;
+ (void)write_confirm;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbWriteDataGetSize(uint32_t num_dwords) {
+ (void)num_dwords;
+ return 0;
+}
+
+int sceAgcDmaDataPatchSetDstAddressOrOffset(uint32_t* cmd, uint64_t dst_address_or_offset) {
+ (void)cmd;
+ (void)dst_address_or_offset;
+ return 0;
+}
+
+int sceAgcDmaDataPatchSetSrcAddressOrOffsetOrImmediate(uint32_t* cmd, uint64_t src_address_or_offset_or_immediate) {
+ (void)cmd;
+ (void)src_address_or_offset_or_immediate;
+ return 0;
+}
+
+int sceAgcGetDataPacketPayloadAddress(uint32_t** addr, uint32_t* cmd, int type) {
+ (void)addr;
+ (void)cmd;
+ (void)type;
+ return 0;
+}
+
+uint32_t sceAgcGetPacketSize(uint32_t* packet) {
+ (void)packet;
+ return 0;
+}
+
+void* sceAgcGetRegisterDefaults2(uint32_t ver) {
+ (void)ver;
+ return nullptr;
+}
+
+void* sceAgcGetRegisterDefaults2Internal(uint32_t ver) {
+ (void)ver;
+ return nullptr;
+}
+
+int sceAgcInit(uint32_t* state, uint32_t ver) {
+ (void)state;
+ (void)ver;
+ return 0;
+}
+
+int sceAgcJumpPatchSetTarget(uint32_t* cmd, const volatile uint32_t* target, uint32_t size_in_dwords) {
+ (void)cmd;
+ (void)target;
+ (void)size_in_dwords;
+ return 0;
+}
+
+int sceAgcQueueEndOfPipeActionPatchAddress(uint32_t* cmd, const volatile Label* address) {
+ (void)cmd;
+ (void)address;
+ return 0;
+}
+
+int sceAgcQueueEndOfPipeActionPatchData(uint32_t* cmd, uint32_t context_id, uint32_t data_sel, uint64_t data) {
+ (void)cmd;
+ (void)context_id;
+ (void)data_sel;
+ (void)data;
+ return 0;
+}
+
+int sceAgcRewindPatchSetRewindState(uint32_t* cmd, uint8_t state) {
+ (void)cmd;
+ (void)state;
+ return 0;
+}
+
+int sceAgcSetCxRegIndirectPatchAddRegisters(uint32_t* cmd, uint32_t num_regs) {
+ (void)cmd;
+ (void)num_regs;
+ return 0;
+}
+
+int sceAgcSetCxRegIndirectPatchSetAddress(uint32_t* cmd, const volatile ShaderRegister* regs) {
+ (void)cmd;
+ (void)regs;
+ return 0;
+}
+
+int sceAgcSetCxRegIndirectPatchSetNumRegisters(uint32_t* cmd, uint32_t num_regs) {
+ (void)cmd;
+ (void)num_regs;
+ return 0;
+}
+
+int sceAgcSetPacketPredication(uint32_t* packet, uint32_t predication) {
+ (void)packet;
+ (void)predication;
+ return 0;
+}
+
+int sceAgcSetRangePredication(uint32_t* start, const volatile uint32_t* end, uint32_t predication) {
+ (void)start;
+ (void)end;
+ (void)predication;
+ return 0;
+}
+
+int sceAgcSetShRegIndirectPatchAddRegisters(uint32_t* cmd, uint32_t num_regs) {
+ (void)cmd;
+ (void)num_regs;
+ return 0;
+}
+
+int sceAgcSetShRegIndirectPatchSetAddress(uint32_t* cmd, const volatile ShaderRegister* regs) {
+ (void)cmd;
+ (void)regs;
+ return 0;
+}
+
+int sceAgcSetShRegIndirectPatchSetNumRegisters(uint32_t* cmd, uint32_t num_regs) {
+ (void)cmd;
+ (void)num_regs;
+ return 0;
+}
+
+int sceAgcSetUcRegIndirectPatchAddRegisters(uint32_t* cmd, uint32_t num_regs) {
+ (void)cmd;
+ (void)num_regs;
+ return 0;
+}
+
+int sceAgcSetUcRegIndirectPatchSetAddress(uint32_t* cmd, const volatile ShaderRegister* regs) {
+ (void)cmd;
+ (void)regs;
+ return 0;
+}
+
+int sceAgcSetUcRegIndirectPatchSetNumRegisters(uint32_t* cmd, uint32_t num_regs) {
+ (void)cmd;
+ (void)num_regs;
+ return 0;
+}
+
+int sceAgcSuspendPoint(void) {
+ return 0;
+}
+
+int sceAgcUpdatePrimState(ShaderRegister* cx_regs, ShaderRegister* uc_regs, uint32_t prim_type) {
+ (void)cx_regs;
+ (void)uc_regs;
+ (void)prim_type;
+ return 0;
+}
+
+int sceAgcWaitRegMemPatchAddress(uint32_t* cmd, const volatile void* address) {
+ (void)cmd;
+ (void)address;
+ return 0;
+}
+
+int sceAgcWaitRegMemPatchReference(uint32_t* cmd, uint64_t reference) {
+ (void)cmd;
+ (void)reference;
+ return 0;
+}
+
+}

core/libs/prx/libSceAgcDriver/Export.cpp

@@ -0,0 +1,119 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceAgcDriverAddEqEvent(KernelEqueue eq, int id, void* udata) {
+ (void)eq;
+ (void)id;
+ (void)udata;
+ return 0;
+}
+
+int sceAgcDriverDeleteEqEvent(KernelEqueue eq, int id) {
+ (void)eq;
+ (void)id;
+ return 0;
+}
+
+uint32_t sceAgcDriverGetEqContextId(const KernelEvent* ev) {
+ (void)ev;
+ return 0;
+}
+
+int sceAgcDriverGetEqEventType(const KernelEvent* ev) {
+ (void)ev;
+ return 0;
+}
+
+uint32_t sceAgcDriverInitResourceRegistration(void) {
+ return 0;
+}
+
+bool sceAgcDriverIsCaptureInProgress(void) {
+ return false;
+}
+
+uint32_t sceAgcDriverQueryResourceRegistrationUserMemoryRequirements(uint64_t* size_in_bytes) {
+ (void)size_in_bytes;
+ return 0;
+}
+
+int sceAgcDriverRegisterOwner(void) {
+ return 0;
+}
+
+int sceAgcDriverRegisterResource(void) {
+ return 0;
+}
+
+int sceAgcDriverRegisterWorkloadStream(uint32_t stream_id, const void* stream) {
+ (void)stream_id;
+ (void)stream;
+ return 0;
+}
+
+int sceAgcDriverSetHsOffchipParam(uint64_t value0, uint64_t value1, uint64_t value2) {
+ (void)value0;
+ (void)value1;
+ (void)value2;
+ return 0;
+}
+
+int sceAgcDriverSetTFRing(const volatile void* base, uint32_t size) {
+ (void)base;
+ (void)size;
+ return 0;
+}
+
+int sceAgcDriverSubmitAcb(uint32_t queue, const Packet* packet) {
+ (void)queue;
+ (void)packet;
+ return 0;
+}
+
+int sceAgcDriverSubmitCommandBuffer(void* queue_context, const Packet* packet) {
+ (void)queue_context;
+ (void)packet;
+ return 0;
+}
+
+int sceAgcDriverSubmitDcb(const Packet* packet) {
+ (void)packet;
+ return 0;
+}
+
+int sceAgcDriverSubmitMultiAcbs(uint32_t queue, uint32_t* const* acbs, const uint32_t* sizes_in_dwords, uint32_t count) {
+ (void)queue;
+ (void)acbs;
+ (void)sizes_in_dwords;
+ (void)count;
+ return 0;
+}
+
+int sceAgcDriverSubmitMultiCommandBuffers(void* queue_context, uint32_t* const* command_buffers, const uint32_t* sizes_in_dwords, uint32_t count) {
+ (void)queue_context;
+ (void)command_buffers;
+ (void)sizes_in_dwords;
+ (void)count;
+ return 0;
+}
+
+int sceAgcDriverSubmitMultiDcbs(uint32_t* const* dcb_gpu_addrs, const uint32_t* dcb_sizes_in_dwords, uint32_t count) {
+ (void)dcb_gpu_addrs;
+ (void)dcb_sizes_in_dwords;
+ (void)count;
+ return 0;
+}
+
+int sceAgcDriverUnregisterOwnerAndResources(uint32_t owner_handle) {
+ (void)owner_handle;
+ return 0;
+}
+
+int sceAgcDriverUnregisterResource(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceAgcVsh/Export.cpp

@@ -0,0 +1,780 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+uint32_t* sceAgcAcbAcquireMem(CommandBuffer* buf, uint32_t gcr_cntl, const volatile void* base, uint64_t size_bytes, uint32_t poll_cycles) {
+ (void)buf;
+ (void)gcr_cntl;
+ (void)base;
+ (void)size_bytes;
+ (void)poll_cycles;
+ return nullptr;
+}
+
+uint32_t sceAgcAcbAcquireMemGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcAcbCondExec(CommandBuffer* buf, const volatile uint32_t* address, uint32_t num_dwords) {
+ (void)buf;
+ (void)address;
+ (void)num_dwords;
+ return nullptr;
+}
+
+uint32_t sceAgcAcbCondExecGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcAcbCopyData(CommandBuffer* buf, uint8_t dst, uint8_t dst_cache_policy, uint64_t dst_address, uint8_t src, uint8_t src_cache_policy, uint64_t src_address_or_immediate, uint8_t item_size, uint8_t write_confirm) {
+ (void)buf;
+ (void)dst;
+ (void)dst_cache_policy;
+ (void)dst_address;
+ (void)src;
+ (void)src_cache_policy;
+ (void)src_address_or_immediate;
+ (void)item_size;
+ (void)write_confirm;
+ return nullptr;
+}
+
+uint32_t* sceAgcAcbDispatchIndirect(CommandBuffer* buf, const volatile void* indirect_args, uint32_t modifier) {
+ (void)buf;
+ (void)indirect_args;
+ (void)modifier;
+ return nullptr;
+}
+
+uint32_t* sceAgcAcbDmaData(CommandBuffer* buf, uint8_t dst, uint8_t dst_cache_policy, uint64_t dst_address_or_offset, uint8_t src, uint8_t src_cache_policy, uint64_t src_address_or_offset_or_immediate, uint32_t num_bytes, uint8_t wait_for_previous, uint8_t write_confirm) {
+ (void)buf;
+ (void)dst;
+ (void)dst_cache_policy;
+ (void)dst_address_or_offset;
+ (void)src;
+ (void)src_cache_policy;
+ (void)src_address_or_offset_or_immediate;
+ (void)num_bytes;
+ (void)wait_for_previous;
+ (void)write_confirm;
+ return nullptr;
+}
+
+uint32_t* sceAgcAcbEventWrite(CommandBuffer* buf, uint8_t event_type, const volatile void* address) {
+ (void)buf;
+ (void)event_type;
+ (void)address;
+ return nullptr;
+}
+
+uint32_t sceAgcAcbJumpGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcAcbPopMarker(CommandBuffer* buf) {
+ (void)buf;
+ return nullptr;
+}
+
+uint32_t* sceAgcAcbPushMarker(CommandBuffer* buf, const char* str, uint32_t color) {
+ (void)buf;
+ (void)str;
+ (void)color;
+ return nullptr;
+}
+
+uint32_t* sceAgcAcbResetQueue(CommandBuffer* buf, uint32_t op) {
+ (void)buf;
+ (void)op;
+ return nullptr;
+}
+
+uint32_t* sceAgcAcbSetMarker(CommandBuffer* buf, const char* str, uint32_t color) {
+ (void)buf;
+ (void)str;
+ (void)color;
+ return nullptr;
+}
+
+uint32_t* sceAgcAcbWaitRegMem(CommandBuffer* buf, uint8_t size, uint8_t compare_function, uint8_t cache_policy, const volatile void* address, uint64_t reference, uint64_t mask, uint32_t poll_cycles) {
+ (void)buf;
+ (void)size;
+ (void)compare_function;
+ (void)cache_policy;
+ (void)address;
+ (void)reference;
+ (void)mask;
+ (void)poll_cycles;
+ return nullptr;
+}
+
+uint32_t* sceAgcAcbWriteData(CommandBuffer* buf, uint8_t dst, uint8_t cache_policy, uint64_t address_or_offset, const void* data, uint32_t num_dwords, uint8_t increment, uint8_t write_confirm) {
+ (void)buf;
+ (void)dst;
+ (void)cache_policy;
+ (void)address_or_offset;
+ (void)data;
+ (void)num_dwords;
+ (void)increment;
+ (void)write_confirm;
+ return nullptr;
+}
+
+uint32_t* sceAgcCbBranch(CommandBuffer* buf, uint8_t mode, uint8_t compare_function, const volatile uint64_t* compare_addr, uint64_t mask, uint64_t reference, uint8_t cache_policy1, const volatile uint32_t* buffer1, uint32_t size_in_dwords1, uint8_t cache_policy2, const volatile uint32_t* buffer2, uint32_t size_in_dwords2) {
+ (void)buf;
+ (void)mode;
+ (void)compare_function;
+ (void)compare_addr;
+ (void)mask;
+ (void)reference;
+ (void)cache_policy1;
+ (void)buffer1;
+ (void)size_in_dwords1;
+ (void)cache_policy2;
+ (void)buffer2;
+ (void)size_in_dwords2;
+ return nullptr;
+}
+
+uint32_t* sceAgcCbDispatch(CommandBuffer* buf, uint32_t thread_group_x, uint32_t thread_group_y, uint32_t thread_group_z, uint32_t modifier) {
+ (void)buf;
+ (void)thread_group_x;
+ (void)thread_group_y;
+ (void)thread_group_z;
+ (void)modifier;
+ return nullptr;
+}
+
+uint32_t sceAgcCbDispatchGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcCbNop(CommandBuffer* buf, uint32_t size_in_dwords) {
+ (void)buf;
+ (void)size_in_dwords;
+ return nullptr;
+}
+
+uint32_t sceAgcCbNopGetSize(uint32_t size_in_dwords) {
+ (void)size_in_dwords;
+ return 0;
+}
+
+uint32_t sceAgcCbQueueEndOfPipeActionGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcCbReleaseMem(CommandBuffer* buf, uint8_t action, uint16_t gcr_cntl, uint8_t dst, uint8_t cache_policy, const volatile Label* address, uint8_t data_sel, uint64_t data, uint16_t gds_offset, uint16_t gds_size, uint8_t interrupt, uint32_t interrupt_ctx_id) {
+ (void)buf;
+ (void)action;
+ (void)gcr_cntl;
+ (void)dst;
+ (void)cache_policy;
+ (void)address;
+ (void)data_sel;
+ (void)data;
+ (void)gds_offset;
+ (void)gds_size;
+ (void)interrupt;
+ (void)interrupt_ctx_id;
+ return nullptr;
+}
+
+uint32_t* sceAgcCbSetShRegisterRangeDirect(CommandBuffer* buf, uint32_t offset, const uint32_t* values, uint32_t num_values) {
+ (void)buf;
+ (void)offset;
+ (void)values;
+ (void)num_values;
+ return nullptr;
+}
+
+uint32_t sceAgcCbSetShRegisterRangeDirectGetSize(uint32_t num_values) {
+ (void)num_values;
+ return 0;
+}
+
+uint32_t* sceAgcCbSetShRegistersDirect(CommandBuffer* buf, const volatile ShaderRegister* regs, uint32_t num_regs) {
+ (void)buf;
+ (void)regs;
+ (void)num_regs;
+ return nullptr;
+}
+
+int sceAgcCondExecPatchSetCommandAddress(uint32_t* cmd, const volatile uint32_t* command) {
+ (void)cmd;
+ (void)command;
+ return 0;
+}
+
+int sceAgcCondExecPatchSetEnd(uint32_t* cmd, const volatile uint32_t* buffer) {
+ (void)cmd;
+ (void)buffer;
+ return 0;
+}
+
+int sceAgcCreateInterpolantMapping(ShaderRegister* regs, const Shader* gs, const Shader* ps) {
+ (void)regs;
+ (void)gs;
+ (void)ps;
+ return 0;
+}
+
+int sceAgcCreatePrimState(ShaderRegister* cx_regs, ShaderRegister* uc_regs, const Shader* hs, const Shader* gs, uint32_t prim_type) {
+ (void)cx_regs;
+ (void)uc_regs;
+ (void)hs;
+ (void)gs;
+ (void)prim_type;
+ return 0;
+}
+
+int sceAgcCreateShader(Shader** dst, void* header, const volatile void* code) {
+ (void)dst;
+ (void)header;
+ (void)code;
+ return 0;
+}
+
+uint32_t* sceAgcDcbAcquireMem(CommandBuffer* buf, uint8_t engine, uint32_t cb_db_op, uint32_t gcr_cntl, const volatile void* base, uint64_t size_bytes, uint32_t poll_cycles) {
+ (void)buf;
+ (void)engine;
+ (void)cb_db_op;
+ (void)gcr_cntl;
+ (void)base;
+ (void)size_bytes;
+ (void)poll_cycles;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbAcquireMemGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbCondExec(CommandBuffer* buf, const volatile uint32_t* address, uint32_t num_dwords) {
+ (void)buf;
+ (void)address;
+ (void)num_dwords;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbCondExecGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbContextStateOp(CommandBuffer* buf, uint32_t operation) {
+ (void)buf;
+ (void)operation;
+ return nullptr;
+}
+
+uint64_t sceAgcDcbContextStateOpGetSize(uint32_t operation) {
+ (void)operation;
+ return 0;
+}
+
+uint32_t* sceAgcDcbCopyData(CommandBuffer* buf, uint8_t dst, uint8_t dst_cache_policy, uint64_t dst_address, uint8_t src, uint8_t src_cache_policy, uint64_t src_address_or_immediate, uint8_t item_size, uint8_t write_confirm) {
+ (void)buf;
+ (void)dst;
+ (void)dst_cache_policy;
+ (void)dst_address;
+ (void)src;
+ (void)src_cache_policy;
+ (void)src_address_or_immediate;
+ (void)item_size;
+ (void)write_confirm;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbDispatchIndirect(CommandBuffer* buf, uint32_t data_offset_in_bytes, uint32_t flags) {
+ (void)buf;
+ (void)data_offset_in_bytes;
+ (void)flags;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbDispatchIndirectGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbDmaData(CommandBuffer* buf, uint8_t engine, uint8_t dst, uint8_t dst_cache_policy, uint64_t dst_address_or_offset, uint8_t src, uint8_t src_cache_policy, uint64_t src_address_or_offset_or_immediate, uint32_t num_bytes, uint8_t wait_for_previous, uint8_t write_confirm, uint8_t block_engine) {
+ (void)buf;
+ (void)engine;
+ (void)dst;
+ (void)dst_cache_policy;
+ (void)dst_address_or_offset;
+ (void)src;
+ (void)src_cache_policy;
+ (void)src_address_or_offset_or_immediate;
+ (void)num_bytes;
+ (void)wait_for_previous;
+ (void)write_confirm;
+ (void)block_engine;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbDrawIndex(CommandBuffer* buf, uint32_t index_count, const volatile void* index_addr, uint64_t modifier) {
+ (void)buf;
+ (void)index_count;
+ (void)index_addr;
+ (void)modifier;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbDrawIndexAuto(CommandBuffer* buf, uint32_t index_count, uint64_t modifier) {
+ (void)buf;
+ (void)index_count;
+ (void)modifier;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbDrawIndexAutoGetSize(void) {
+ return 0;
+}
+
+uint32_t sceAgcDcbDrawIndexGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbDrawIndexIndirect(CommandBuffer* buf, uint32_t data_offset_in_bytes, uint64_t modifier) {
+ (void)buf;
+ (void)data_offset_in_bytes;
+ (void)modifier;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbDrawIndexIndirectMulti(CommandBuffer* buf, uint32_t data_offset_in_bytes, uint32_t count_indirect, uint32_t max_count_or_count, const volatile void* count_addr, uint32_t stride_in_bytes, uint64_t modifier) {
+ (void)buf;
+ (void)data_offset_in_bytes;
+ (void)count_indirect;
+ (void)max_count_or_count;
+ (void)count_addr;
+ (void)stride_in_bytes;
+ (void)modifier;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbDrawIndexMultiInstanced(CommandBuffer* buf, uint32_t index_count, const volatile void* index_addr, const volatile void* object_ids, uint32_t instance_count, uint64_t modifier) {
+ (void)buf;
+ (void)index_count;
+ (void)index_addr;
+ (void)object_ids;
+ (void)instance_count;
+ (void)modifier;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbDrawIndexMultiInstancedGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbDrawIndexOffset(CommandBuffer* buf, uint32_t index_offset, uint32_t index_count, uint64_t modifier) {
+ (void)buf;
+ (void)index_offset;
+ (void)index_count;
+ (void)modifier;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbDrawIndexOffsetGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbDrawIndirect(CommandBuffer* buf, uint32_t data_offset_in_bytes, uint64_t modifier) {
+ (void)buf;
+ (void)data_offset_in_bytes;
+ (void)modifier;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbDrawIndirectGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbEventWrite(CommandBuffer* buf, uint8_t event_type, const volatile void* address) {
+ (void)buf;
+ (void)event_type;
+ (void)address;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbGetLodStats(CommandBuffer* buf, uint8_t cache_policy, const volatile void* buffer, uint32_t buffer_size_in_bytes, uint32_t reset_count, uint8_t force_reset, uint8_t report_and_reset, uint32_t reporting_interval_in_100k_clocks) {
+ (void)buf;
+ (void)cache_policy;
+ (void)buffer;
+ (void)buffer_size_in_bytes;
+ (void)reset_count;
+ (void)force_reset;
+ (void)report_and_reset;
+ (void)reporting_interval_in_100k_clocks;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbJump(CommandBuffer* buf, uint8_t mode, uint8_t cache_policy, const uint32_t* target, uint32_t size_in_dwords) {
+ (void)buf;
+ (void)mode;
+ (void)cache_policy;
+ (void)target;
+ (void)size_in_dwords;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbJumpGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbPopMarker(CommandBuffer* buf) {
+ (void)buf;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbPushMarker(CommandBuffer* buf, const char* str, uint32_t color) {
+ (void)buf;
+ (void)str;
+ (void)color;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbResetQueue(CommandBuffer* buf, uint32_t op, uint32_t state) {
+ (void)buf;
+ (void)op;
+ (void)state;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbRewind(CommandBuffer* buf, uint32_t initial_state) {
+ (void)buf;
+ (void)initial_state;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbRewindGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbSetBaseIndirectArgs(CommandBuffer* buf, uint32_t shader_type, const volatile void* indirect_base_addr) {
+ (void)buf;
+ (void)shader_type;
+ (void)indirect_base_addr;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetCxRegisterDirect(CommandBuffer* buf, ShaderRegister reg) {
+ (void)buf;
+ (void)reg;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbSetCxRegisterDirectGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbSetCxRegistersIndirect(CommandBuffer* buf, const volatile ShaderRegister* regs, uint32_t num_regs) {
+ (void)buf;
+ (void)regs;
+ (void)num_regs;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetFlip(CommandBuffer* buf, uint32_t video_out_handle, int32_t display_buffer_index, uint32_t flip_mode, int64_t flip_arg) {
+ (void)buf;
+ (void)video_out_handle;
+ (void)display_buffer_index;
+ (void)flip_mode;
+ (void)flip_arg;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetIndexBuffer(CommandBuffer* buf, uint64_t index_addr) {
+ (void)buf;
+ (void)index_addr;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetIndexCount(CommandBuffer* buf, uint32_t index_count) {
+ (void)buf;
+ (void)index_count;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetIndexSize(CommandBuffer* buf, uint8_t index_size, uint8_t cache_policy) {
+ (void)buf;
+ (void)index_size;
+ (void)cache_policy;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetMarker(CommandBuffer* buf, const char* str, uint32_t color) {
+ (void)buf;
+ (void)str;
+ (void)color;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetNumInstances(CommandBuffer* buf, uint32_t num_instances) {
+ (void)buf;
+ (void)num_instances;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbSetNumInstancesGetSize(void) {
+ return 0;
+}
+
+uint32_t* sceAgcDcbSetPredication(CommandBuffer* buf, uint8_t condition, uint8_t op, uint8_t wait_op, const volatile void* address, uint32_t count_in_dwords) {
+ (void)buf;
+ (void)condition;
+ (void)op;
+ (void)wait_op;
+ (void)address;
+ (void)count_in_dwords;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetShRegisterDirect(CommandBuffer* buf, ShaderRegister reg) {
+ (void)buf;
+ (void)reg;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetShRegistersIndirect(CommandBuffer* buf, const volatile ShaderRegister* regs, uint32_t num_regs) {
+ (void)buf;
+ (void)regs;
+ (void)num_regs;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetUcRegisterDirect(CommandBuffer* buf, ShaderRegister reg) {
+ (void)buf;
+ (void)reg;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetUcRegistersIndirect(CommandBuffer* buf, const volatile ShaderRegister* regs, uint32_t num_regs) {
+ (void)buf;
+ (void)regs;
+ (void)num_regs;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetWorkloadComplete(CommandBuffer* buf, uint32_t stream_id, uint32_t workload_id) {
+ (void)buf;
+ (void)stream_id;
+ (void)workload_id;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbSetWorkloadsActive(CommandBuffer* buf, uint32_t stream_id, const uint32_t* workload_ids, uint32_t workload_count) {
+ (void)buf;
+ (void)stream_id;
+ (void)workload_ids;
+ (void)workload_count;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbStallCommandBufferParser(CommandBuffer* buf) {
+ (void)buf;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbWaitOnAddressGetSize(uint32_t size) {
+ (void)size;
+ return 0;
+}
+
+uint32_t* sceAgcDcbWaitRegMem(CommandBuffer* buf, uint8_t size, uint8_t compare_function, uint8_t op, uint8_t cache_policy, const volatile void* address, uint64_t reference, uint64_t mask, uint32_t poll_cycles) {
+ (void)buf;
+ (void)size;
+ (void)compare_function;
+ (void)op;
+ (void)cache_policy;
+ (void)address;
+ (void)reference;
+ (void)mask;
+ (void)poll_cycles;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbWaitUntilSafeForRendering(CommandBuffer* buf, uint32_t video_out_handle, uint32_t display_buffer_index) {
+ (void)buf;
+ (void)video_out_handle;
+ (void)display_buffer_index;
+ return nullptr;
+}
+
+uint32_t* sceAgcDcbWriteData(CommandBuffer* buf, uint8_t dst, uint8_t cache_policy, uint64_t address_or_offset, const void* data, uint32_t num_dwords, uint8_t increment, uint8_t write_confirm) {
+ (void)buf;
+ (void)dst;
+ (void)cache_policy;
+ (void)address_or_offset;
+ (void)data;
+ (void)num_dwords;
+ (void)increment;
+ (void)write_confirm;
+ return nullptr;
+}
+
+uint32_t sceAgcDcbWriteDataGetSize(uint32_t num_dwords) {
+ (void)num_dwords;
+ return 0;
+}
+
+int sceAgcDmaDataPatchSetDstAddressOrOffset(uint32_t* cmd, uint64_t dst_address_or_offset) {
+ (void)cmd;
+ (void)dst_address_or_offset;
+ return 0;
+}
+
+int sceAgcDmaDataPatchSetSrcAddressOrOffsetOrImmediate(uint32_t* cmd, uint64_t src_address_or_offset_or_immediate) {
+ (void)cmd;
+ (void)src_address_or_offset_or_immediate;
+ return 0;
+}
+
+int sceAgcGetDataPacketPayloadAddress(uint32_t** addr, uint32_t* cmd, int type) {
+ (void)addr;
+ (void)cmd;
+ (void)type;
+ return 0;
+}
+
+uint32_t sceAgcGetPacketSize(uint32_t* packet) {
+ (void)packet;
+ return 0;
+}
+
+void* sceAgcGetRegisterDefaults2(uint32_t ver) {
+ (void)ver;
+ return nullptr;
+}
+
+void* sceAgcGetRegisterDefaults2Internal(uint32_t ver) {
+ (void)ver;
+ return nullptr;
+}
+
+int sceAgcInit(uint32_t* state, uint32_t ver) {
+ (void)state;
+ (void)ver;
+ return 0;
+}
+
+int sceAgcJumpPatchSetTarget(uint32_t* cmd, const volatile uint32_t* target, uint32_t size_in_dwords) {
+ (void)cmd;
+ (void)target;
+ (void)size_in_dwords;
+ return 0;
+}
+
+int sceAgcQueueEndOfPipeActionPatchAddress(uint32_t* cmd, const volatile Label* address) {
+ (void)cmd;
+ (void)address;
+ return 0;
+}
+
+int sceAgcQueueEndOfPipeActionPatchData(uint32_t* cmd, uint32_t context_id, uint32_t data_sel, uint64_t data) {
+ (void)cmd;
+ (void)context_id;
+ (void)data_sel;
+ (void)data;
+ return 0;
+}
+
+int sceAgcRewindPatchSetRewindState(uint32_t* cmd, uint8_t state) {
+ (void)cmd;
+ (void)state;
+ return 0;
+}
+
+int sceAgcSetCxRegIndirectPatchAddRegisters(uint32_t* cmd, uint32_t num_regs) {
+ (void)cmd;
+ (void)num_regs;
+ return 0;
+}
+
+int sceAgcSetCxRegIndirectPatchSetAddress(uint32_t* cmd, const volatile ShaderRegister* regs) {
+ (void)cmd;
+ (void)regs;
+ return 0;
+}
+
+int sceAgcSetCxRegIndirectPatchSetNumRegisters(uint32_t* cmd, uint32_t num_regs) {
+ (void)cmd;
+ (void)num_regs;
+ return 0;
+}
+
+int sceAgcSetPacketPredication(uint32_t* packet, uint32_t predication) {
+ (void)packet;
+ (void)predication;
+ return 0;
+}
+
+int sceAgcSetRangePredication(uint32_t* start, const volatile uint32_t* end, uint32_t predication) {
+ (void)start;
+ (void)end;
+ (void)predication;
+ return 0;
+}
+
+int sceAgcSetShRegIndirectPatchAddRegisters(uint32_t* cmd, uint32_t num_regs) {
+ (void)cmd;
+ (void)num_regs;
+ return 0;
+}
+
+int sceAgcSetShRegIndirectPatchSetAddress(uint32_t* cmd, const volatile ShaderRegister* regs) {
+ (void)cmd;
+ (void)regs;
+ return 0;
+}
+
+int sceAgcSetShRegIndirectPatchSetNumRegisters(uint32_t* cmd, uint32_t num_regs) {
+ (void)cmd;
+ (void)num_regs;
+ return 0;
+}
+
+int sceAgcSetUcRegIndirectPatchAddRegisters(uint32_t* cmd, uint32_t num_regs) {
+ (void)cmd;
+ (void)num_regs;
+ return 0;
+}
+
+int sceAgcSetUcRegIndirectPatchSetAddress(uint32_t* cmd, const volatile ShaderRegister* regs) {
+ (void)cmd;
+ (void)regs;
+ return 0;
+}
+
+int sceAgcSetUcRegIndirectPatchSetNumRegisters(uint32_t* cmd, uint32_t num_regs) {
+ (void)cmd;
+ (void)num_regs;
+ return 0;
+}
+
+int sceAgcSuspendPoint(void) {
+ return 0;
+}
+
+int sceAgcUpdatePrimState(ShaderRegister* cx_regs, ShaderRegister* uc_regs, uint32_t prim_type) {
+ (void)cx_regs;
+ (void)uc_regs;
+ (void)prim_type;
+ return 0;
+}
+
+int sceAgcWaitRegMemPatchAddress(uint32_t* cmd, const volatile void* address) {
+ (void)cmd;
+ (void)address;
+ return 0;
+}
+
+int sceAgcWaitRegMemPatchReference(uint32_t* cmd, uint64_t reference) {
+ (void)cmd;
+ (void)reference;
+ return 0;
+}
+
+}

core/libs/prx/libSceAjm.native/Export.cpp

@@ -0,0 +1,266 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceAjmBatchCancel(uint32_t context, uint32_t batch) {
+ (void)context;
+ (void)batch;
+ return 0;
+}
+
+int sceAjmBatchErrorDump(const AjmBatchInfo* info, AjmBatchError* error) {
+ (void)info;
+ (void)error;
+ return 0;
+}
+
+int sceAjmBatchInitialize(void* buffer, size_t size, AjmBatchInfo* info) {
+ (void)buffer;
+ (void)size;
+ (void)info;
+ return 0;
+}
+
+int sceAjmBatchJobClearContext(AjmBatchInfo* info, uint32_t instance, void* result) {
+ (void)info;
+ (void)instance;
+ (void)result;
+ return 0;
+}
+
+int sceAjmBatchJobControl(AjmBatchInfo* info, uint32_t instance, uint64_t flags, const void* sideband_input, size_t sideband_input_size, void* sideband_output, size_t sideband_output_size) {
+ (void)info;
+ (void)instance;
+ (void)flags;
+ (void)sideband_input;
+ (void)sideband_input_size;
+ (void)sideband_output;
+ (void)sideband_output_size;
+ return 0;
+}
+
+int sceAjmBatchJobDecode(AjmBatchInfo* info, uint32_t instance, const void* bitstream_input, size_t bitstream_input_size, void* pcm_output, size_t pcm_output_size, void* result) {
+ (void)info;
+ (void)instance;
+ (void)bitstream_input;
+ (void)bitstream_input_size;
+ (void)pcm_output;
+ (void)pcm_output_size;
+ (void)result;
+ return 0;
+}
+
+int sceAjmBatchJobDecodeSingle(AjmBatchInfo* info, uint32_t instance, const void* bitstream_input, size_t bitstream_input_size, void* pcm_output, size_t pcm_output_size, void* result) {
+ (void)info;
+ (void)instance;
+ (void)bitstream_input;
+ (void)bitstream_input_size;
+ (void)pcm_output;
+ (void)pcm_output_size;
+ (void)result;
+ return 0;
+}
+
+int sceAjmBatchJobDecodeSplit(AjmBatchInfo* info, uint32_t instance, const AjmBuffer* input_buffers, size_t input_buffers_num, const AjmBuffer* output_buffers, size_t output_buffers_num, void* result) {
+ (void)info;
+ (void)instance;
+ (void)input_buffers;
+ (void)input_buffers_num;
+ (void)output_buffers;
+ (void)output_buffers_num;
+ (void)result;
+ return 0;
+}
+
+int sceAjmBatchJobEncode(AjmBatchInfo* info, uint32_t instance, const void* pcm_input, size_t pcm_input_size, void* bitstream_output, size_t bitstream_output_size, void* result) {
+ (void)info;
+ (void)instance;
+ (void)pcm_input;
+ (void)pcm_input_size;
+ (void)bitstream_output;
+ (void)bitstream_output_size;
+ (void)result;
+ return 0;
+}
+
+int sceAjmBatchJobGetCodecInfo(AjmBatchInfo* info, uint32_t instance, void* result, size_t result_size) {
+ (void)info;
+ (void)instance;
+ (void)result;
+ (void)result_size;
+ return 0;
+}
+
+int sceAjmBatchJobGetGaplessDecode(AjmBatchInfo* info, uint32_t instance, void* result) {
+ (void)info;
+ (void)instance;
+ (void)result;
+ return 0;
+}
+
+int sceAjmBatchJobGetInfo(AjmBatchInfo* info, uint32_t instance, void* result) {
+ (void)info;
+ (void)instance;
+ (void)result;
+ return 0;
+}
+
+int sceAjmBatchJobGetResampleInfo(AjmBatchInfo* info, uint32_t instance, void* result) {
+ (void)info;
+ (void)instance;
+ (void)result;
+ return 0;
+}
+
+int sceAjmBatchJobGetStatistics(AjmBatchInfo* info, float interval, void* result) {
+ (void)info;
+ (void)interval;
+ (void)result;
+ return 0;
+}
+
+int sceAjmBatchJobInitialize(AjmBatchInfo* info, uint32_t instance, const void* codec_parameters, size_t codec_parameters_size, void* result) {
+ (void)info;
+ (void)instance;
+ (void)codec_parameters;
+ (void)codec_parameters_size;
+ (void)result;
+ return 0;
+}
+
+int sceAjmBatchJobRun(AjmBatchInfo* info, uint32_t instance, uint64_t flags, const void* data_input, size_t data_input_size, void* data_output, size_t data_output_size, void* sideband_output, size_t sideband_output_size) {
+ (void)info;
+ (void)instance;
+ (void)flags;
+ (void)data_input;
+ (void)data_input_size;
+ (void)data_output;
+ (void)data_output_size;
+ (void)sideband_output;
+ (void)sideband_output_size;
+ return 0;
+}
+
+int sceAjmBatchJobRunSplit(AjmBatchInfo* info, uint32_t instance, uint64_t flags, const AjmBuffer* input_buffers, size_t input_buffers_num, const AjmBuffer* output_buffers, size_t output_buffers_num, void* sideband_output, size_t sideband_output_size) {
+ (void)info;
+ (void)instance;
+ (void)flags;
+ (void)input_buffers;
+ (void)input_buffers_num;
+ (void)output_buffers;
+ (void)output_buffers_num;
+ (void)sideband_output;
+ (void)sideband_output_size;
+ return 0;
+}
+
+int sceAjmBatchJobSetGaplessDecode(AjmBatchInfo* info, uint32_t instance, const void* gapless_decode, int reset, void* result) {
+ (void)info;
+ (void)instance;
+ (void)gapless_decode;
+ (void)reset;
+ (void)result;
+ return 0;
+}
+
+int sceAjmBatchJobSetResampleParameters(AjmBatchInfo* info, uint32_t instance, float ratio, uint32_t flags, void* result) {
+ (void)info;
+ (void)instance;
+ (void)ratio;
+ (void)flags;
+ (void)result;
+ return 0;
+}
+
+int sceAjmBatchJobSetResampleParametersEx(AjmBatchInfo* info, uint32_t instance, float ratio_start, float ratio_change_per_sample, uint32_t flags, void* result) {
+ (void)info;
+ (void)instance;
+ (void)ratio_start;
+ (void)ratio_change_per_sample;
+ (void)flags;
+ (void)result;
+ return 0;
+}
+
+int sceAjmBatchStart(uint32_t context, const AjmBatchInfo* info, int priority, AjmBatchError* error, uint32_t* batch) {
+ (void)context;
+ (void)info;
+ (void)priority;
+ (void)error;
+ (void)batch;
+ return 0;
+}
+
+int sceAjmBatchWait(uint32_t context, uint32_t batch, uint32_t timeout, AjmBatchError* error) {
+ (void)context;
+ (void)batch;
+ (void)timeout;
+ (void)error;
+ return 0;
+}
+
+int sceAjmDecAt9ParseConfigData(const void* config_data, AjmDecAt9ConfigDataInfo* config_info) {
+ (void)config_data;
+ (void)config_info;
+ return 0;
+}
+
+int sceAjmFinalize(uint32_t context) {
+ (void)context;
+ return 0;
+}
+
+int sceAjmInitialize(int64_t reserved, uint32_t* context) {
+ (void)reserved;
+ (void)context;
+ return 0;
+}
+
+int sceAjmInstanceCreate(uint32_t context, uint32_t codec, uint64_t flags, uint32_t* instance) {
+ (void)context;
+ (void)codec;
+ (void)flags;
+ (void)instance;
+ return 0;
+}
+
+int sceAjmInstanceDestroy(uint32_t context, uint32_t instance) {
+ (void)context;
+ (void)instance;
+ return 0;
+}
+
+int sceAjmMemoryRegister(uint32_t context, void* ptr, size_t pages) {
+ (void)context;
+ (void)ptr;
+ (void)pages;
+ return 0;
+}
+
+int sceAjmMemoryUnregister(uint32_t context, void* ptr) {
+ (void)context;
+ (void)ptr;
+ return 0;
+}
+
+int sceAjmModuleRegister(uint32_t context, uint32_t codec, int64_t reserved) {
+ (void)context;
+ (void)codec;
+ (void)reserved;
+ return 0;
+}
+
+int sceAjmModuleUnregister(uint32_t context, uint32_t codec) {
+ (void)context;
+ (void)codec;
+ return 0;
+}
+
+const char* sceAjmStrError(int error) {
+ (void)error;
+ return nullptr;
+}
+
+}

core/libs/prx/libSceAjm/Export.cpp

@@ -0,0 +1,89 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceAjmBatchCancel(uint32_t context, uint32_t batch) {
+ (void)context;
+ (void)batch;
+ return 0;
+}
+
+int sceAjmBatchErrorDump(const AjmBatchInfo* info, AjmBatchError* error) {
+ (void)info;
+ (void)error;
+ return 0;
+}
+
+int sceAjmBatchWait(uint32_t context, uint32_t batch, uint32_t timeout, AjmBatchError* error) {
+ (void)context;
+ (void)batch;
+ (void)timeout;
+ (void)error;
+ return 0;
+}
+
+int sceAjmDecAt9ParseConfigData(const void* config_data, AjmDecAt9ConfigDataInfo* config_info) {
+ (void)config_data;
+ (void)config_info;
+ return 0;
+}
+
+int sceAjmFinalize(uint32_t context) {
+ (void)context;
+ return 0;
+}
+
+int sceAjmInitialize(int64_t reserved, uint32_t* context) {
+ (void)reserved;
+ (void)context;
+ return 0;
+}
+
+int sceAjmInstanceCreate(uint32_t context, uint32_t codec, uint64_t flags, uint32_t* instance) {
+ (void)context;
+ (void)codec;
+ (void)flags;
+ (void)instance;
+ return 0;
+}
+
+int sceAjmInstanceDestroy(uint32_t context, uint32_t instance) {
+ (void)context;
+ (void)instance;
+ return 0;
+}
+
+int sceAjmMemoryRegister(uint32_t context, void* ptr, size_t pages) {
+ (void)context;
+ (void)ptr;
+ (void)pages;
+ return 0;
+}
+
+int sceAjmMemoryUnregister(uint32_t context, void* ptr) {
+ (void)context;
+ (void)ptr;
+ return 0;
+}
+
+int sceAjmModuleRegister(uint32_t context, uint32_t codec, int64_t reserved) {
+ (void)context;
+ (void)codec;
+ (void)reserved;
+ return 0;
+}
+
+int sceAjmModuleUnregister(uint32_t context, uint32_t codec) {
+ (void)context;
+ (void)codec;
+ return 0;
+}
+
+const char* sceAjmStrError(int error) {
+ (void)error;
+ return nullptr;
+}
+
+}

core/libs/prx/libSceAjmi/Export.cpp

@@ -0,0 +1,89 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceAjmBatchCancel(uint32_t context, uint32_t batch) {
+ (void)context;
+ (void)batch;
+ return 0;
+}
+
+int sceAjmBatchErrorDump(const AjmBatchInfo* info, AjmBatchError* error) {
+ (void)info;
+ (void)error;
+ return 0;
+}
+
+int sceAjmBatchWait(uint32_t context, uint32_t batch, uint32_t timeout, AjmBatchError* error) {
+ (void)context;
+ (void)batch;
+ (void)timeout;
+ (void)error;
+ return 0;
+}
+
+int sceAjmDecAt9ParseConfigData(const void* config_data, AjmDecAt9ConfigDataInfo* config_info) {
+ (void)config_data;
+ (void)config_info;
+ return 0;
+}
+
+int sceAjmFinalize(uint32_t context) {
+ (void)context;
+ return 0;
+}
+
+int sceAjmInitialize(int64_t reserved, uint32_t* context) {
+ (void)reserved;
+ (void)context;
+ return 0;
+}
+
+int sceAjmInstanceCreate(uint32_t context, uint32_t codec, uint64_t flags, uint32_t* instance) {
+ (void)context;
+ (void)codec;
+ (void)flags;
+ (void)instance;
+ return 0;
+}
+
+int sceAjmInstanceDestroy(uint32_t context, uint32_t instance) {
+ (void)context;
+ (void)instance;
+ return 0;
+}
+
+int sceAjmMemoryRegister(uint32_t context, void* ptr, size_t pages) {
+ (void)context;
+ (void)ptr;
+ (void)pages;
+ return 0;
+}
+
+int sceAjmMemoryUnregister(uint32_t context, void* ptr) {
+ (void)context;
+ (void)ptr;
+ return 0;
+}
+
+int sceAjmModuleRegister(uint32_t context, uint32_t codec, int64_t reserved) {
+ (void)context;
+ (void)codec;
+ (void)reserved;
+ return 0;
+}
+
+int sceAjmModuleUnregister(uint32_t context, uint32_t codec) {
+ (void)context;
+ (void)codec;
+ return 0;
+}
+
+const char* sceAjmStrError(int error) {
+ (void)error;
+ return nullptr;
+}
+
+}

core/libs/prx/libSceAppContent/Export.cpp

@@ -0,0 +1,54 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceAppContentAddcontMount(uint32_t service_label, const NpUnifiedEntitlementLabel* entitlement_label, AppContentMountPoint* mount_point) {
+ (void)service_label;
+ (void)entitlement_label;
+ (void)mount_point;
+ return 0;
+}
+
+int sceAppContentAddcontUnmount(const AppContentMountPoint* mount_point) {
+ (void)mount_point;
+ return 0;
+}
+
+int sceAppContentAppParamGetInt(uint32_t param_id, int32_t* value) {
+ (void)param_id;
+ (void)value;
+ return 0;
+}
+
+int sceAppContentDownloadDataGetAvailableSpaceKb(const AppContentMountPoint* mount_point, size_t* available_space_kb) {
+ (void)mount_point;
+ (void)available_space_kb;
+ return 0;
+}
+
+int sceAppContentInitialize(const AppContentInitParam* init_param, AppContentBootParam* boot_param) {
+ (void)init_param;
+ (void)boot_param;
+ return 0;
+}
+
+int sceAppContentTemporaryDataFormat(const AppContentMountPoint* mount_point) {
+ (void)mount_point;
+ return 0;
+}
+
+int sceAppContentTemporaryDataGetAvailableSpaceKb(const AppContentMountPoint* mount_point, size_t* available_space_kb) {
+ (void)mount_point;
+ (void)available_space_kb;
+ return 0;
+}
+
+int sceAppContentTemporaryDataMount2(uint32_t option, AppContentMountPoint* mount_point) {
+ (void)option;
+ (void)mount_point;
+ return 0;
+}
+
+}

core/libs/prx/libSceAudio/Export.cpp

@@ -1,4 +1,5 @@
 #include <cstdint>
+#include "SceTypes.hpp"
 
 extern "C" {
 

core/libs/prx/libSceAudio3d/Export.cpp

@@ -0,0 +1,49 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+void sceAudio3dGetDefaultOpenParameters(Audio3dOpenParameters* p) {
+ (void)p;
+}
+
+int sceAudio3dInitialize(int64_t reserved) {
+ (void)reserved;
+ return 0;
+}
+
+int sceAudio3dPortAdvance(uint32_t port_id) {
+ (void)port_id;
+ return 0;
+}
+
+int sceAudio3dPortGetQueueLevel(uint32_t port_id, uint32_t* queue_level, uint32_t* queue_available) {
+ (void)port_id;
+ (void)queue_level;
+ (void)queue_available;
+ return 0;
+}
+
+int sceAudio3dPortOpen(int user_id, const Audio3dOpenParameters* parameters, uint32_t* id) {
+ (void)user_id;
+ (void)parameters;
+ (void)id;
+ return 0;
+}
+
+int sceAudio3dPortPush(uint32_t port_id, uint32_t blocking) {
+ (void)port_id;
+ (void)blocking;
+ return 0;
+}
+
+int sceAudio3dPortSetAttribute(uint32_t port_id, uint32_t attribute_id, const void* attribute, size_t attribute_size) {
+ (void)port_id;
+ (void)attribute_id;
+ (void)attribute;
+ (void)attribute_size;
+ return 0;
+}
+
+}

core/libs/prx/libSceAudioIn/Export.cpp

@@ -0,0 +1,28 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceAudioInGetSilentState(int handle) {
+ (void)handle;
+ return 0;
+}
+
+int sceAudioInInput(int handle, void* dest) {
+ (void)handle;
+ (void)dest;
+ return 0;
+}
+
+int sceAudioInOpen(int user_id, uint32_t type, uint32_t index, uint32_t len, uint32_t freq, uint32_t param) {
+ (void)user_id;
+ (void)type;
+ (void)index;
+ (void)len;
+ (void)freq;
+ (void)param;
+ return 0;
+}
+
+}

core/libs/prx/libSceAudioOut/Export.cpp

@@ -0,0 +1,217 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceAudioOut2ContextAdvance(AudioOut2ContextHandle ctx) {
+ (void)ctx;
+ return 0;
+}
+
+int sceAudioOut2ContextCreate(const AudioOut2ContextParam* params, void* buffer, size_t buffer_size, AudioOut2ContextHandle* ctx) {
+ (void)params;
+ (void)buffer;
+ (void)buffer_size;
+ (void)ctx;
+ return 0;
+}
+
+int sceAudioOut2ContextDestroy(AudioOut2ContextHandle ctx) {
+ (void)ctx;
+ return 0;
+}
+
+int sceAudioOut2ContextGetQueueLevel(AudioOut2ContextHandle ctx, uint32_t* queue_level, uint32_t* available_queues) {
+ (void)ctx;
+ (void)queue_level;
+ (void)available_queues;
+ return 0;
+}
+
+int sceAudioOut2ContextPush(AudioOut2ContextHandle ctx, uint32_t blocking) {
+ (void)ctx;
+ (void)blocking;
+ return 0;
+}
+
+int sceAudioOut2ContextQueryMemory(const AudioOut2ContextParam* params, size_t* memory_size) {
+ (void)params;
+ (void)memory_size;
+ return 0;
+}
+
+int sceAudioOut2ContextResetParam(AudioOut2ContextParam* params) {
+ (void)params;
+ return 0;
+}
+
+int sceAudioOut2ContextSetAttributes(AudioOut2ContextHandle ctx, const AudioOut2Attribute* attributes, uint32_t num) {
+ (void)ctx;
+ (void)attributes;
+ (void)num;
+ return 0;
+}
+
+int sceAudioOut2GetSpeakerArrayAmbisonicsCoefficients(AudioOut2SpeakerArrayHandle handle, uint32_t ambisonics_channel, float* coefficients, uint32_t num_coefficients) {
+ (void)handle;
+ (void)ambisonics_channel;
+ (void)coefficients;
+ (void)num_coefficients;
+ return 0;
+}
+
+int sceAudioOut2GetSpeakerArrayCoefficients(AudioOut2SpeakerArrayHandle handle, AudioOut2Position pos, float spread, float* coefficients, uint32_t num_coefficients, uint8_t height_aware, float downmix_spread_radius) {
+ (void)handle;
+ (void)pos;
+ (void)spread;
+ (void)coefficients;
+ (void)num_coefficients;
+ (void)height_aware;
+ (void)downmix_spread_radius;
+ return 0;
+}
+
+size_t sceAudioOut2GetSpeakerArrayMemorySize(uint32_t num_speakers, uint8_t is_3d, uint8_t is_ambisonics) {
+ (void)num_speakers;
+ (void)is_3d;
+ (void)is_ambisonics;
+ return 0;
+}
+
+int sceAudioOut2GetSpeakerInfo(AudioOut2SpeakerInfo* info, uint32_t flags) {
+ (void)info;
+ (void)flags;
+ return 0;
+}
+
+int sceAudioOut2GetSystemState(AudioOut2SystemState* state) {
+ (void)state;
+ return 0;
+}
+
+int sceAudioOut2Initialize(void) {
+ return 0;
+}
+
+int sceAudioOut2MasteringGetState(AudioOut2MasteringStatesHeader* state, uint32_t output, AudioOut2UserHandle user) {
+ (void)state;
+ (void)output;
+ (void)user;
+ return 0;
+}
+
+int sceAudioOut2MasteringInit(uint32_t flags) {
+ (void)flags;
+ return 0;
+}
+
+int sceAudioOut2MasteringSetParam(const AudioOut2MasteringParamsHeader* param, uint32_t output, uint32_t flags) {
+ (void)param;
+ (void)output;
+ (void)flags;
+ return 0;
+}
+
+int sceAudioOut2MasteringTerm(void) {
+ return 0;
+}
+
+int sceAudioOut2PortCreate(AudioOut2ContextHandle ctx, const AudioOut2PortParam* params, AudioOut2PortHandle* port) {
+ (void)ctx;
+ (void)params;
+ (void)port;
+ return 0;
+}
+
+int sceAudioOut2PortDestroy(AudioOut2PortHandle port) {
+ (void)port;
+ return 0;
+}
+
+int sceAudioOut2PortGetState(AudioOut2PortHandle port, AudioOut2PortState* state) {
+ (void)port;
+ (void)state;
+ return 0;
+}
+
+int sceAudioOut2PortSetAttributes(AudioOut2PortHandle port, const AudioOut2Attribute* attributes, uint32_t num) {
+ (void)port;
+ (void)attributes;
+ (void)num;
+ return 0;
+}
+
+int sceAudioOut2SetSystemDebugState(const AudioOut2SystemDebugStateParam* param) {
+ (void)param;
+ return 0;
+}
+
+int sceAudioOut2SpeakerArrayCreate(AudioOut2SpeakerArrayHandle* handle, const void* vbap_params, const void* ambi_params) {
+ (void)handle;
+ (void)vbap_params;
+ (void)ambi_params;
+ return 0;
+}
+
+int sceAudioOut2SpeakerArrayDestroy(AudioOut2SpeakerArrayHandle handle) {
+ (void)handle;
+ return 0;
+}
+
+int sceAudioOut2UserCreate(uint32_t user_id, AudioOut2UserHandle* handle) {
+ (void)user_id;
+ (void)handle;
+ return 0;
+}
+
+int sceAudioOut2UserDestroy(AudioOut2UserHandle handle) {
+ (void)handle;
+ return 0;
+}
+
+int sceAudioOutClose(int handle) {
+ (void)handle;
+ return 0;
+}
+
+int sceAudioOutGetPortState(int handle, AudioOutPortState* state) {
+ (void)handle;
+ (void)state;
+ return 0;
+}
+
+int sceAudioOutInit(void) {
+ return 0;
+}
+
+int sceAudioOutOpen(int user_id, int type, int index, uint32_t len, uint32_t freq, uint32_t param) {
+ (void)user_id;
+ (void)type;
+ (void)index;
+ (void)len;
+ (void)freq;
+ (void)param;
+ return 0;
+}
+
+int sceAudioOutOutput(int handle, const void* ptr) {
+ (void)handle;
+ (void)ptr;
+ return 0;
+}
+
+int sceAudioOutOutputs(AudioOutOutputParam* param, uint32_t num) {
+ (void)param;
+ (void)num;
+ return 0;
+}
+
+int sceAudioOutSetVolume(int handle, uint32_t flag, int* vol) {
+ (void)handle;
+ (void)flag;
+ (void)vol;
+ return 0;
+}
+
+}

core/libs/prx/libSceAudioPropagation/Export.cpp

@@ -0,0 +1,47 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int32_t sceAudioPropagationRoomCreate(AudioPropagationHandle system_handle, AudioPropagationHandle* out_room_handle) {
+ (void)system_handle;
+ (void)out_room_handle;
+ return 0;
+}
+
+int32_t sceAudioPropagationSystemCreate(const void* options, AudioPropagationSystemMemory* memory, AudioPropagationHandle* out_system_handle) {
+ (void)options;
+ (void)memory;
+ (void)out_system_handle;
+ return 0;
+}
+
+int32_t sceAudioPropagationSystemGetRays(AudioPropagationHandle system_handle, void* rays, uint32_t* num_rays) {
+ (void)system_handle;
+ (void)rays;
+ (void)num_rays;
+ return 0;
+}
+
+int32_t sceAudioPropagationSystemQueryMemory(const void* options, AudioPropagationSystemMemory* out_memory) {
+ (void)options;
+ (void)out_memory;
+ return 0;
+}
+
+int32_t sceAudioPropagationSystemRegisterMaterial(AudioPropagationHandle system_handle, const void* material, AudioPropagationHandle* out_material_handle) {
+ (void)system_handle;
+ (void)material;
+ (void)out_material_handle;
+ return 0;
+}
+
+int32_t sceAudioPropagationSystemSetAttributes(AudioPropagationHandle system_handle, const void* attributes, uint32_t num_attributes) {
+ (void)system_handle;
+ (void)attributes;
+ (void)num_attributes;
+ return 0;
+}
+
+}

core/libs/prx/libSceAudiodec.native/Export.cpp

@@ -0,0 +1,39 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int32_t sceAudiodecClearContext(int32_t handle) {
+ (void)handle;
+ return 0;
+}
+
+int32_t sceAudiodecCreateDecoder(AudiodecCtrl* ctrl, uint32_t codec_type) {
+ (void)ctrl;
+ (void)codec_type;
+ return 0;
+}
+
+int32_t sceAudiodecDecode(int32_t handle, AudiodecCtrl* ctrl) {
+ (void)handle;
+ (void)ctrl;
+ return 0;
+}
+
+int32_t sceAudiodecDeleteDecoder(int32_t handle) {
+ (void)handle;
+ return 0;
+}
+
+int32_t sceAudiodecInitLibrary(uint32_t codec_type) {
+ (void)codec_type;
+ return 0;
+}
+
+int32_t sceAudiodecTermLibrary(uint32_t codec_type) {
+ (void)codec_type;
+ return 0;
+}
+
+}

core/libs/prx/libSceAudiodec/Export.cpp

@@ -0,0 +1,39 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int32_t sceAudiodecClearContext(int32_t handle) {
+ (void)handle;
+ return 0;
+}
+
+int32_t sceAudiodecCreateDecoder(AudiodecCtrl* ctrl, uint32_t codec_type) {
+ (void)ctrl;
+ (void)codec_type;
+ return 0;
+}
+
+int32_t sceAudiodecDecode(int32_t handle, AudiodecCtrl* ctrl) {
+ (void)handle;
+ (void)ctrl;
+ return 0;
+}
+
+int32_t sceAudiodecDeleteDecoder(int32_t handle) {
+ (void)handle;
+ return 0;
+}
+
+int32_t sceAudiodecInitLibrary(uint32_t codec_type) {
+ (void)codec_type;
+ return 0;
+}
+
+int32_t sceAudiodecTermLibrary(uint32_t codec_type) {
+ (void)codec_type;
+ return 0;
+}
+
+}

core/libs/prx/libSceAvPlayer.native/Export.cpp

@@ -0,0 +1,166 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceAvPlayerAddSource(AvPlayerInternal* h, const char* filename) {
+ (void)h;
+ (void)filename;
+ return 0;
+}
+
+int sceAvPlayerAddSourceEx(AvPlayerInternal* h, uint32_t uri_type, const void* source_details) {
+ (void)h;
+ (void)uri_type;
+ (void)source_details;
+ return 0;
+}
+
+int sceAvPlayerChangeStream(AvPlayerInternal* h, uint32_t old_stream_id, uint32_t new_stream_id) {
+ (void)h;
+ (void)old_stream_id;
+ (void)new_stream_id;
+ return 0;
+}
+
+int sceAvPlayerClose(AvPlayerInternal* h) {
+ (void)h;
+ return 0;
+}
+
+uint64_t sceAvPlayerCurrentTime(AvPlayerInternal* h) {
+ (void)h;
+ return 0;
+}
+
+int sceAvPlayerDisableStream(AvPlayerInternal* h, uint32_t stream_id) {
+ (void)h;
+ (void)stream_id;
+ return 0;
+}
+
+int sceAvPlayerEnableStream(AvPlayerInternal* h, uint32_t stream_id) {
+ (void)h;
+ (void)stream_id;
+ return 0;
+}
+
+Bool sceAvPlayerGetAudioData(AvPlayerInternal* h, AvPlayerFrameInfo* audio_info) {
+ (void)h;
+ (void)audio_info;
+ return {};
+}
+
+int sceAvPlayerGetStreamInfo(AvPlayerInternal* h, uint32_t stream_id, void* info) {
+ (void)h;
+ (void)stream_id;
+ (void)info;
+ return 0;
+}
+
+int sceAvPlayerGetStreamInfoEx(AvPlayerInternal* h, uint32_t stream_id, void* info) {
+ (void)h;
+ (void)stream_id;
+ (void)info;
+ return 0;
+}
+
+Bool sceAvPlayerGetVideoDataEx(AvPlayerInternal* h, AvPlayerFrameInfoEx* video_info) {
+ (void)h;
+ (void)video_info;
+ return {};
+}
+
+AvPlayerInternal* sceAvPlayerInit(AvPlayerInitData* init) {
+ (void)init;
+ return nullptr;
+}
+
+int sceAvPlayerInitEx(const void* init_ex, AvPlayerInternal** handle) {
+ (void)init_ex;
+ (void)handle;
+ return 0;
+}
+
+Bool sceAvPlayerIsActive(AvPlayerInternal* h) {
+ (void)h;
+ return {};
+}
+
+int sceAvPlayerJumpToTime(AvPlayerInternal* h, uint64_t time_ms) {
+ (void)h;
+ (void)time_ms;
+ return 0;
+}
+
+int sceAvPlayerPause(AvPlayerInternal* h) {
+ (void)h;
+ return 0;
+}
+
+int sceAvPlayerPostInit(AvPlayerInternal* h, const void* post_init) {
+ (void)h;
+ (void)post_init;
+ return 0;
+}
+
+int sceAvPlayerResume(AvPlayerInternal* h) {
+ (void)h;
+ return 0;
+}
+
+int sceAvPlayerSetAvailableBandwidth(AvPlayerInternal* h, uint32_t start_bandwidth, uint32_t minimum_bandwidth, uint32_t maximum_bandwidth) {
+ (void)h;
+ (void)start_bandwidth;
+ (void)minimum_bandwidth;
+ (void)maximum_bandwidth;
+ return 0;
+}
+
+int sceAvPlayerSetAvSyncMode(AvPlayerInternal* h, uint32_t sync_mode) {
+ (void)h;
+ (void)sync_mode;
+ return 0;
+}
+
+int sceAvPlayerSetLogCallback(void* callback, void* user_data) {
+ (void)callback;
+ (void)user_data;
+ return 0;
+}
+
+int sceAvPlayerSetLooping(AvPlayerInternal* h, Bool loop) {
+ (void)h;
+ (void)loop;
+ return 0;
+}
+
+int sceAvPlayerSetTrickSpeed(AvPlayerInternal* h, int32_t trick_speed) {
+ (void)h;
+ (void)trick_speed;
+ return 0;
+}
+
+int sceAvPlayerStart(AvPlayerInternal* h) {
+ (void)h;
+ return 0;
+}
+
+int sceAvPlayerStartEx(AvPlayerInternal* h, const void* start_info_ex) {
+ (void)h;
+ (void)start_info_ex;
+ return 0;
+}
+
+int sceAvPlayerStop(AvPlayerInternal* h) {
+ (void)h;
+ return 0;
+}
+
+int sceAvPlayerStreamCount(AvPlayerInternal* h) {
+ (void)h;
+ return 0;
+}
+
+}

core/libs/prx/libSceAvPlayer/Export.cpp

@@ -0,0 +1,151 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceAvPlayerAddSource(AvPlayerInternal* h, const char* filename) {
+ (void)h;
+ (void)filename;
+ return 0;
+}
+
+int sceAvPlayerAddSourceEx(AvPlayerInternal* h, uint32_t uri_type, const void* source_details) {
+ (void)h;
+ (void)uri_type;
+ (void)source_details;
+ return 0;
+}
+
+int sceAvPlayerChangeStream(AvPlayerInternal* h, uint32_t old_stream_id, uint32_t new_stream_id) {
+ (void)h;
+ (void)old_stream_id;
+ (void)new_stream_id;
+ return 0;
+}
+
+int sceAvPlayerClose(AvPlayerInternal* h) {
+ (void)h;
+ return 0;
+}
+
+uint64_t sceAvPlayerCurrentTime(AvPlayerInternal* h) {
+ (void)h;
+ return 0;
+}
+
+int sceAvPlayerDisableStream(AvPlayerInternal* h, uint32_t stream_id) {
+ (void)h;
+ (void)stream_id;
+ return 0;
+}
+
+int sceAvPlayerEnableStream(AvPlayerInternal* h, uint32_t stream_id) {
+ (void)h;
+ (void)stream_id;
+ return 0;
+}
+
+Bool sceAvPlayerGetAudioData(AvPlayerInternal* h, AvPlayerFrameInfo* audio_info) {
+ (void)h;
+ (void)audio_info;
+ return {};
+}
+
+int sceAvPlayerGetStreamInfo(AvPlayerInternal* h, uint32_t stream_id, void* info) {
+ (void)h;
+ (void)stream_id;
+ (void)info;
+ return 0;
+}
+
+Bool sceAvPlayerGetVideoData(AvPlayerInternal* h, AvPlayerFrameInfo* video_info) {
+ (void)h;
+ (void)video_info;
+ return {};
+}
+
+Bool sceAvPlayerGetVideoDataEx(AvPlayerInternal* h, AvPlayerFrameInfoEx* video_info) {
+ (void)h;
+ (void)video_info;
+ return {};
+}
+
+AvPlayerInternal* sceAvPlayerInit(AvPlayerInitData* init) {
+ (void)init;
+ return nullptr;
+}
+
+int sceAvPlayerInitEx(const void* init_ex, AvPlayerInternal** handle) {
+ (void)init_ex;
+ (void)handle;
+ return 0;
+}
+
+Bool sceAvPlayerIsActive(AvPlayerInternal* h) {
+ (void)h;
+ return {};
+}
+
+int sceAvPlayerJumpToTime(AvPlayerInternal* h, uint64_t time_ms) {
+ (void)h;
+ (void)time_ms;
+ return 0;
+}
+
+int sceAvPlayerPause(AvPlayerInternal* h) {
+ (void)h;
+ return 0;
+}
+
+int sceAvPlayerPostInit(AvPlayerInternal* h, const void* post_init) {
+ (void)h;
+ (void)post_init;
+ return 0;
+}
+
+int sceAvPlayerResume(AvPlayerInternal* h) {
+ (void)h;
+ return 0;
+}
+
+int sceAvPlayerSetAvSyncMode(AvPlayerInternal* h, uint32_t sync_mode) {
+ (void)h;
+ (void)sync_mode;
+ return 0;
+}
+
+int sceAvPlayerSetLogCallback(void* callback, void* user_data) {
+ (void)callback;
+ (void)user_data;
+ return 0;
+}
+
+int sceAvPlayerSetLooping(AvPlayerInternal* h, Bool loop) {
+ (void)h;
+ (void)loop;
+ return 0;
+}
+
+int sceAvPlayerSetTrickSpeed(AvPlayerInternal* h, int32_t trick_speed) {
+ (void)h;
+ (void)trick_speed;
+ return 0;
+}
+
+int sceAvPlayerStart(AvPlayerInternal* h) {
+ (void)h;
+ return 0;
+}
+
+int sceAvPlayerStop(AvPlayerInternal* h) {
+ (void)h;
+ return 0;
+}
+
+int sceAvPlayerStreamCount(AvPlayerInternal* h) {
+ (void)h;
+ return 0;
+}
+
+}

core/libs/prx/libSceCesCs/Export.cpp

@@ -0,0 +1,29 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+const uint8_t* sceCesRefersUcsProfileCp1252(void) {
+ return nullptr;
+}
+
+int sceCesSbcToUtf8(const uint8_t* profile, uint8_t sbc, uint8_t* utf8, uint32_t utf8max, uint32_t* utf8_len) {
+ (void)profile;
+ (void)sbc;
+ (void)utf8;
+ (void)utf8max;
+ (void)utf8_len;
+ return 0;
+}
+
+int sceCesUtf8ToSbc(const uint8_t* utf8, uint32_t utf8max, uint32_t* utf8_len, const uint8_t* profile, uint8_t* sbc) {
+ (void)utf8;
+ (void)utf8max;
+ (void)utf8_len;
+ (void)profile;
+ (void)sbc;
+ return 0;
+}
+
+}

core/libs/prx/libSceCommonDialog/Export.cpp

@@ -0,0 +1,15 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceCommonDialogInitialize(void) {
+ return 0;
+}
+
+bool sceCommonDialogIsUsed(void) {
+ return false;
+}
+
+}

core/libs/prx/libSceContentDelete/Export.cpp

@@ -0,0 +1,12 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceContentDeleteInitialize(const ContentDeleteInitParam* init_param) {
+ (void)init_param;
+ return 0;
+}
+
+}

core/libs/prx/libSceContentExport/Export.cpp

@@ -0,0 +1,12 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceContentExportInit2(const ContentExportInitParam2* init_param) {
+ (void)init_param;
+ return 0;
+}
+
+}

core/libs/prx/libSceContentSearch/Export.cpp

@@ -0,0 +1,12 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceContentSearchInit(const ContentSearchInitParam* init_param) {
+ (void)init_param;
+ return 0;
+}
+
+}

core/libs/prx/libSceErrorDialog/Export.cpp

@@ -0,0 +1,32 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceErrorDialogClose(void) {
+ return 0;
+}
+
+int sceErrorDialogGetStatus(void) {
+ return 0;
+}
+
+int sceErrorDialogInitialize(void) {
+ return 0;
+}
+
+int sceErrorDialogOpen(const void* param) {
+ (void)param;
+ return 0;
+}
+
+int sceErrorDialogTerminate(void) {
+ return 0;
+}
+
+int sceErrorDialogUpdateStatus(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceFiber/Export.cpp

@@ -0,0 +1,68 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int32_t sceFiberFinalize(FiberObject* fiber) {
+ (void)fiber;
+ return 0;
+}
+
+int32_t sceFiberGetInfo(FiberObject* fiber, FiberInfo* fiber_info) {
+ (void)fiber;
+ (void)fiber_info;
+ return 0;
+}
+
+int32_t sceFiberGetSelf(FiberObject** fiber) {
+ (void)fiber;
+ return 0;
+}
+
+int32_t sceFiberGetThreadFramePointerAddress(uint64_t* addr_frame_pointer) {
+ (void)addr_frame_pointer;
+ return 0;
+}
+
+int32_t sceFiberOptParamInitialize(FiberOptParam* opt_param) {
+ (void)opt_param;
+ return 0;
+}
+
+int32_t sceFiberRename(FiberObject* fiber, const char* name) {
+ (void)fiber;
+ (void)name;
+ return 0;
+}
+
+int32_t sceFiberReturnToThread(uint64_t arg_on_return, uint64_t* arg_on_run) {
+ (void)arg_on_return;
+ (void)arg_on_run;
+ return 0;
+}
+
+int32_t sceFiberRun(FiberObject* fiber, uint64_t arg_on_run, uint64_t* arg_on_return) {
+ (void)fiber;
+ (void)arg_on_run;
+ (void)arg_on_return;
+ return 0;
+}
+
+int32_t sceFiberStartContextSizeCheck(uint32_t flags) {
+ (void)flags;
+ return 0;
+}
+
+int32_t sceFiberStopContextSizeCheck(void) {
+ return 0;
+}
+
+int32_t sceFiberSwitch(FiberObject* fiber, uint64_t arg_on_run, uint64_t* arg_on_return) {
+ (void)fiber;
+ (void)arg_on_run;
+ (void)arg_on_return;
+ return 0;
+}
+
+}

core/libs/prx/libSceFont.native/Export.cpp

@@ -0,0 +1,451 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceFontAttachDeviceCacheBuffer(FontLibrary library, void* buffer, uint32_t size) {
+ (void)library;
+ (void)buffer;
+ (void)size;
+ return 0;
+}
+
+int sceFontBindRenderer(FontHandle font_handle, FontRenderer renderer) {
+ (void)font_handle;
+ (void)renderer;
+ return 0;
+}
+
+int sceFontCharacterGetBidiLevel(FontTextCharacter text_character, int* bidi_level) {
+ (void)text_character;
+ (void)bidi_level;
+ return 0;
+}
+
+int sceFontCharacterGetSyllableStringState(FontTextCharacter text_character, int* syllable_string_state) {
+ (void)text_character;
+ (void)syllable_string_state;
+ return 0;
+}
+
+int sceFontCharacterGetTextFontCode(FontTextCharacter text_character, FontHandle* font_handle, uint32_t* text_code) {
+ (void)text_character;
+ (void)font_handle;
+ (void)text_code;
+ return 0;
+}
+
+int sceFontCharacterGetTextOrder(FontTextCharacter text_character, void** text_order) {
+ (void)text_character;
+ (void)text_order;
+ return 0;
+}
+
+uint32_t sceFontCharacterLooksFormatCharacters(FontTextCharacter text_character) {
+ (void)text_character;
+ return 0;
+}
+
+uint32_t sceFontCharacterLooksWhiteSpace(FontTextCharacter text_character) {
+ (void)text_character;
+ return 0;
+}
+
+FontTextCharacter sceFontCharacterRefersTextBack(FontTextCharacter text_character) {
+ (void)text_character;
+ return {};
+}
+
+FontTextCharacter sceFontCharacterRefersTextNext(FontTextCharacter text_character) {
+ (void)text_character;
+ return {};
+}
+
+FontTextCodes* sceFontCharactersRefersTextCodes(FontTextCharacter text_character, FontTextCharacter term_character, FontTextCodes* text_codes) {
+ (void)text_character;
+ (void)term_character;
+ (void)text_codes;
+ return nullptr;
+}
+
+int sceFontCloseFont(FontHandle font_handle) {
+ (void)font_handle;
+ return 0;
+}
+
+int sceFontCreateLibrary(const FontMemory* memory, FontLibrarySelection selection, FontLibrary* library) {
+ (void)memory;
+ (void)selection;
+ (void)library;
+ return 0;
+}
+
+int sceFontCreateLibraryWithEdition(const FontMemory* memory, FontLibrarySelection selection, uint64_t edition, FontLibrary* library) {
+ (void)memory;
+ (void)selection;
+ (void)edition;
+ (void)library;
+ return 0;
+}
+
+int sceFontCreateRendererWithEdition(const FontMemory* memory, FontRendererSelection selection, uint64_t edition, FontRenderer* renderer) {
+ (void)memory;
+ (void)selection;
+ (void)edition;
+ (void)renderer;
+ return 0;
+}
+
+int sceFontCreateString(const FontMemory* memory, FontTextSource* font_text_source, const FontCreateStringDetail* string_detail, FontString* font_string) {
+ (void)memory;
+ (void)font_text_source;
+ (void)string_detail;
+ (void)font_string;
+ return 0;
+}
+
+int sceFontCreateWritingLine(const FontMemory* memory, int writing_form, const void* writing_line_detail, FontWritingLine* writing_line) {
+ (void)memory;
+ (void)writing_form;
+ (void)writing_line_detail;
+ (void)writing_line;
+ return 0;
+}
+
+int sceFontDefineAttribute(FontHandle font_handle, int attribute, int* old_attribute) {
+ (void)font_handle;
+ (void)attribute;
+ (void)old_attribute;
+ return 0;
+}
+
+int sceFontDeleteGlyph(const FontMemory* memory, void** font_glyph) {
+ (void)memory;
+ (void)font_glyph;
+ return 0;
+}
+
+int sceFontDestroyLibrary(FontLibrary* library) {
+ (void)library;
+ return 0;
+}
+
+int sceFontDestroyRenderer(FontRenderer* renderer) {
+ (void)renderer;
+ return 0;
+}
+
+int sceFontDestroyString(FontString* font_string) {
+ (void)font_string;
+ return 0;
+}
+
+int sceFontDestroyWritingLine(FontWritingLine* writing_line) {
+ (void)writing_line;
+ return 0;
+}
+
+int sceFontGenerateCharGlyph(FontHandle font_handle, uint32_t code, const FontGenerateGlyphDetail* detail, void** font_glyph) {
+ (void)font_handle;
+ (void)code;
+ (void)detail;
+ (void)font_glyph;
+ return 0;
+}
+
+int sceFontGetCharGlyphMetrics(FontHandle font_handle, uint32_t code, FontGlyphMetrics* metrics) {
+ (void)font_handle;
+ (void)code;
+ (void)metrics;
+ return 0;
+}
+
+int sceFontGetHorizontalLayout(FontHandle font_handle, FontHorizontalLayout* layout) {
+ (void)font_handle;
+ (void)layout;
+ return 0;
+}
+
+int sceFontGetRenderCharGlyphMetrics(FontHandle font_handle, uint32_t code, FontGlyphMetrics* metrics) {
+ (void)font_handle;
+ (void)code;
+ (void)metrics;
+ return 0;
+}
+
+int sceFontGetVerticalLayout(FontHandle font_handle, FontVerticalLayout* layout) {
+ (void)font_handle;
+ (void)layout;
+ return 0;
+}
+
+int sceFontGlyphDefineAttribute(void* font_glyph, int attribute, int* old_attribute) {
+ (void)font_glyph;
+ (void)attribute;
+ (void)old_attribute;
+ return 0;
+}
+
+int sceFontMemoryInit(FontMemory* font_memory, void* address, uint32_t size_byte, const FontMemoryInterface* mem_interface, void* mspace_object, FontMemoryDestroyCallback destroy_callback, void* destroy_object) {
+ (void)font_memory;
+ (void)address;
+ (void)size_byte;
+ (void)mem_interface;
+ (void)mspace_object;
+ (void)destroy_callback;
+ (void)destroy_object;
+ return 0;
+}
+
+int sceFontMemoryTerm(FontMemory* font_memory) {
+ (void)font_memory;
+ return 0;
+}
+
+int sceFontOpenFontInstance(FontHandle font_handle, void* setup_font, FontHandle* out_font_handle) {
+ (void)font_handle;
+ (void)setup_font;
+ (void)out_font_handle;
+ return 0;
+}
+
+int sceFontOpenFontMemory(FontLibrary library, const void* font_address, uint32_t font_size, const FontOpenDetail* detail, FontHandle* handle) {
+ (void)library;
+ (void)font_address;
+ (void)font_size;
+ (void)detail;
+ (void)handle;
+ return 0;
+}
+
+int sceFontOpenFontSet(FontLibrary library, uint32_t font_set_type, uint32_t open_mode, const FontOpenDetail* detail, FontHandle* handle) {
+ (void)library;
+ (void)font_set_type;
+ (void)open_mode;
+ (void)detail;
+ (void)handle;
+ return 0;
+}
+
+int sceFontRebindRenderer(FontHandle font_handle) {
+ (void)font_handle;
+ return 0;
+}
+
+int sceFontRenderCharGlyphImageHorizontal(FontHandle font_handle, uint32_t code, FontRenderSurface* surf, float x, float y, FontGlyphMetrics* metrics, FontRenderResult* result) {
+ (void)font_handle;
+ (void)code;
+ (void)surf;
+ (void)x;
+ (void)y;
+ (void)metrics;
+ (void)result;
+ return 0;
+}
+
+void sceFontRenderSurfaceInit(FontRenderSurface* surf, void* buffer, int buf_width_byte, int pixel_size_byte, int width, int height) {
+ (void)surf;
+ (void)buffer;
+ (void)buf_width_byte;
+ (void)pixel_size_byte;
+ (void)width;
+ (void)height;
+}
+
+void sceFontRenderSurfaceSetScissor(FontRenderSurface* surf, uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1) {
+ (void)surf;
+ (void)x0;
+ (void)y0;
+ (void)x1;
+ (void)y1;
+}
+
+int sceFontSetEffectSlant(FontHandle font_handle, float slant_ratio) {
+ (void)font_handle;
+ (void)slant_ratio;
+ return 0;
+}
+
+int sceFontSetEffectWeight(FontHandle font_handle, float weight_x_scale, float weight_y_scale, uint32_t mode) {
+ (void)font_handle;
+ (void)weight_x_scale;
+ (void)weight_y_scale;
+ (void)mode;
+ return 0;
+}
+
+int sceFontSetScalePixel(FontHandle font_handle, float w, float h) {
+ (void)font_handle;
+ (void)w;
+ (void)h;
+ return 0;
+}
+
+int sceFontSetupRenderEffectSlant(FontHandle font_handle, float slant_ratio) {
+ (void)font_handle;
+ (void)slant_ratio;
+ return 0;
+}
+
+int sceFontSetupRenderEffectWeight(FontHandle font_handle, float weight_x_scale, float weight_y_scale, uint32_t mode) {
+ (void)font_handle;
+ (void)weight_x_scale;
+ (void)weight_y_scale;
+ (void)mode;
+ return 0;
+}
+
+int sceFontSetupRenderScalePixel(FontHandle font_handle, float w, float h) {
+ (void)font_handle;
+ (void)w;
+ (void)h;
+ return 0;
+}
+
+uint32_t sceFontStringGetTerminateCode(FontString font_string) {
+ (void)font_string;
+ return 0;
+}
+
+void* sceFontStringGetTerminateOrder(FontString font_string) {
+ (void)font_string;
+ return nullptr;
+}
+
+int sceFontStringGetWritingForm(FontString font_string) {
+ (void)font_string;
+ return 0;
+}
+
+FontRenderCharacter sceFontStringRefersRenderCharacters(FontString font_string, FontTextCharacter start_character, FontTextCharacter last_character, uint32_t* character_count) {
+ (void)font_string;
+ (void)start_character;
+ (void)last_character;
+ (void)character_count;
+ return {};
+}
+
+FontTextCharacter sceFontStringRefersTextCharacters(FontString font_string, uint32_t* character_count) {
+ (void)font_string;
+ (void)character_count;
+ return {};
+}
+
+int sceFontSupportExternalFonts(FontLibrary library, uint32_t font_max, uint32_t formats) {
+ (void)library;
+ (void)font_max;
+ (void)formats;
+ return 0;
+}
+
+int sceFontSupportSystemFonts(FontLibrary library) {
+ (void)library;
+ return 0;
+}
+
+FontTextCodes* sceFontTextCodesStepBack(FontTextCodes* text_codes_step) {
+ (void)text_codes_step;
+ return nullptr;
+}
+
+FontTextCodes* sceFontTextCodesStepNext(FontTextCodes* text_codes_step) {
+ (void)text_codes_step;
+ return nullptr;
+}
+
+int sceFontTextSourceInit(FontTextSource* font_text_source, const void* text_address, uint32_t text_size_byte, FontTextParseFunction text_parser, void* text_object) {
+ (void)font_text_source;
+ (void)text_address;
+ (void)text_size_byte;
+ (void)text_parser;
+ (void)text_object;
+ return 0;
+}
+
+int sceFontTextSourceRewind(FontTextSource* font_text_source) {
+ (void)font_text_source;
+ return 0;
+}
+
+int sceFontTextSourceSetDefaultFont(FontTextSource* font_text_source, FontHandle default_font) {
+ (void)font_text_source;
+ (void)default_font;
+ return 0;
+}
+
+int sceFontTextSourceSetWritingForm(FontTextSource* font_text_source, int writing_form) {
+ (void)font_text_source;
+ (void)writing_form;
+ return 0;
+}
+
+int sceFontUnbindRenderer(FontHandle font_handle) {
+ (void)font_handle;
+ return 0;
+}
+
+int sceFontWritingGetRenderMetrics(FontWriting* font_writing, FontWritingMetrics* writing_metrics) {
+ (void)font_writing;
+ (void)writing_metrics;
+ return 0;
+}
+
+int sceFontWritingInit(FontWriting* font_writing, FontString font_string, FontRenderCharacter font_character) {
+ (void)font_writing;
+ (void)font_string;
+ (void)font_character;
+ return 0;
+}
+
+int sceFontWritingLineClear(FontWritingLine writing_line) {
+ (void)writing_line;
+ return 0;
+}
+
+int sceFontWritingLineGetOrderingSpace(FontWritingLine writing_line, float* head_space, float* inline_space, float* tail_space, float* advance_space) {
+ (void)writing_line;
+ (void)head_space;
+ (void)inline_space;
+ (void)tail_space;
+ (void)advance_space;
+ return 0;
+}
+
+int sceFontWritingLineGetRenderMetrics(FontWritingLine writing_line, FontWritingMetrics* writing_metrics) {
+ (void)writing_line;
+ (void)writing_metrics;
+ return 0;
+}
+
+FontWritingLineStep* sceFontWritingLineRefersRenderStep(FontWritingLine writing_line) {
+ (void)writing_line;
+ return nullptr;
+}
+
+int sceFontWritingLineWritesOrder(FontWritingLine writing_line, uint64_t writing_attribute, const FontWritingMetrics* writing_metrics, void* writing_orderer) {
+ (void)writing_line;
+ (void)writing_attribute;
+ (void)writing_metrics;
+ (void)writing_orderer;
+ return 0;
+}
+
+const FontWritingStep* sceFontWritingRefersRenderStep(FontWriting* font_writing) {
+ (void)font_writing;
+ return nullptr;
+}
+
+FontTextCharacter sceFontWritingRefersRenderStepCharacter(FontWriting* font_writing, const void** letter_step) {
+ (void)font_writing;
+ (void)letter_step;
+ return {};
+}
+
+int sceFontWritingSetMaskInvisible(FontWriting* font_writing, int mask) {
+ (void)font_writing;
+ (void)mask;
+ return 0;
+}
+
+}

core/libs/prx/libSceFont/Export.cpp

@@ -0,0 +1,451 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceFontAttachDeviceCacheBuffer(FontLibrary library, void* buffer, uint32_t size) {
+ (void)library;
+ (void)buffer;
+ (void)size;
+ return 0;
+}
+
+int sceFontBindRenderer(FontHandle font_handle, FontRenderer renderer) {
+ (void)font_handle;
+ (void)renderer;
+ return 0;
+}
+
+int sceFontCharacterGetBidiLevel(FontTextCharacter text_character, int* bidi_level) {
+ (void)text_character;
+ (void)bidi_level;
+ return 0;
+}
+
+int sceFontCharacterGetSyllableStringState(FontTextCharacter text_character, int* syllable_string_state) {
+ (void)text_character;
+ (void)syllable_string_state;
+ return 0;
+}
+
+int sceFontCharacterGetTextFontCode(FontTextCharacter text_character, FontHandle* font_handle, uint32_t* text_code) {
+ (void)text_character;
+ (void)font_handle;
+ (void)text_code;
+ return 0;
+}
+
+int sceFontCharacterGetTextOrder(FontTextCharacter text_character, void** text_order) {
+ (void)text_character;
+ (void)text_order;
+ return 0;
+}
+
+uint32_t sceFontCharacterLooksFormatCharacters(FontTextCharacter text_character) {
+ (void)text_character;
+ return 0;
+}
+
+uint32_t sceFontCharacterLooksWhiteSpace(FontTextCharacter text_character) {
+ (void)text_character;
+ return 0;
+}
+
+FontTextCharacter sceFontCharacterRefersTextBack(FontTextCharacter text_character) {
+ (void)text_character;
+ return {};
+}
+
+FontTextCharacter sceFontCharacterRefersTextNext(FontTextCharacter text_character) {
+ (void)text_character;
+ return {};
+}
+
+FontTextCodes* sceFontCharactersRefersTextCodes(FontTextCharacter text_character, FontTextCharacter term_character, FontTextCodes* text_codes) {
+ (void)text_character;
+ (void)term_character;
+ (void)text_codes;
+ return nullptr;
+}
+
+int sceFontCloseFont(FontHandle font_handle) {
+ (void)font_handle;
+ return 0;
+}
+
+int sceFontCreateLibrary(const FontMemory* memory, FontLibrarySelection selection, FontLibrary* library) {
+ (void)memory;
+ (void)selection;
+ (void)library;
+ return 0;
+}
+
+int sceFontCreateLibraryWithEdition(const FontMemory* memory, FontLibrarySelection selection, uint64_t edition, FontLibrary* library) {
+ (void)memory;
+ (void)selection;
+ (void)edition;
+ (void)library;
+ return 0;
+}
+
+int sceFontCreateRendererWithEdition(const FontMemory* memory, FontRendererSelection selection, uint64_t edition, FontRenderer* renderer) {
+ (void)memory;
+ (void)selection;
+ (void)edition;
+ (void)renderer;
+ return 0;
+}
+
+int sceFontCreateString(const FontMemory* memory, FontTextSource* font_text_source, const FontCreateStringDetail* string_detail, FontString* font_string) {
+ (void)memory;
+ (void)font_text_source;
+ (void)string_detail;
+ (void)font_string;
+ return 0;
+}
+
+int sceFontCreateWritingLine(const FontMemory* memory, int writing_form, const void* writing_line_detail, FontWritingLine* writing_line) {
+ (void)memory;
+ (void)writing_form;
+ (void)writing_line_detail;
+ (void)writing_line;
+ return 0;
+}
+
+int sceFontDefineAttribute(FontHandle font_handle, int attribute, int* old_attribute) {
+ (void)font_handle;
+ (void)attribute;
+ (void)old_attribute;
+ return 0;
+}
+
+int sceFontDeleteGlyph(const FontMemory* memory, void** font_glyph) {
+ (void)memory;
+ (void)font_glyph;
+ return 0;
+}
+
+int sceFontDestroyLibrary(FontLibrary* library) {
+ (void)library;
+ return 0;
+}
+
+int sceFontDestroyRenderer(FontRenderer* renderer) {
+ (void)renderer;
+ return 0;
+}
+
+int sceFontDestroyString(FontString* font_string) {
+ (void)font_string;
+ return 0;
+}
+
+int sceFontDestroyWritingLine(FontWritingLine* writing_line) {
+ (void)writing_line;
+ return 0;
+}
+
+int sceFontGenerateCharGlyph(FontHandle font_handle, uint32_t code, const FontGenerateGlyphDetail* detail, void** font_glyph) {
+ (void)font_handle;
+ (void)code;
+ (void)detail;
+ (void)font_glyph;
+ return 0;
+}
+
+int sceFontGetCharGlyphMetrics(FontHandle font_handle, uint32_t code, FontGlyphMetrics* metrics) {
+ (void)font_handle;
+ (void)code;
+ (void)metrics;
+ return 0;
+}
+
+int sceFontGetHorizontalLayout(FontHandle font_handle, FontHorizontalLayout* layout) {
+ (void)font_handle;
+ (void)layout;
+ return 0;
+}
+
+int sceFontGetRenderCharGlyphMetrics(FontHandle font_handle, uint32_t code, FontGlyphMetrics* metrics) {
+ (void)font_handle;
+ (void)code;
+ (void)metrics;
+ return 0;
+}
+
+int sceFontGetVerticalLayout(FontHandle font_handle, FontVerticalLayout* layout) {
+ (void)font_handle;
+ (void)layout;
+ return 0;
+}
+
+int sceFontGlyphDefineAttribute(void* font_glyph, int attribute, int* old_attribute) {
+ (void)font_glyph;
+ (void)attribute;
+ (void)old_attribute;
+ return 0;
+}
+
+int sceFontMemoryInit(FontMemory* font_memory, void* address, uint32_t size_byte, const FontMemoryInterface* mem_interface, void* mspace_object, FontMemoryDestroyCallback destroy_callback, void* destroy_object) {
+ (void)font_memory;
+ (void)address;
+ (void)size_byte;
+ (void)mem_interface;
+ (void)mspace_object;
+ (void)destroy_callback;
+ (void)destroy_object;
+ return 0;
+}
+
+int sceFontMemoryTerm(FontMemory* font_memory) {
+ (void)font_memory;
+ return 0;
+}
+
+int sceFontOpenFontInstance(FontHandle font_handle, void* setup_font, FontHandle* out_font_handle) {
+ (void)font_handle;
+ (void)setup_font;
+ (void)out_font_handle;
+ return 0;
+}
+
+int sceFontOpenFontMemory(FontLibrary library, const void* font_address, uint32_t font_size, const FontOpenDetail* detail, FontHandle* handle) {
+ (void)library;
+ (void)font_address;
+ (void)font_size;
+ (void)detail;
+ (void)handle;
+ return 0;
+}
+
+int sceFontOpenFontSet(FontLibrary library, uint32_t font_set_type, uint32_t open_mode, const FontOpenDetail* detail, FontHandle* handle) {
+ (void)library;
+ (void)font_set_type;
+ (void)open_mode;
+ (void)detail;
+ (void)handle;
+ return 0;
+}
+
+int sceFontRebindRenderer(FontHandle font_handle) {
+ (void)font_handle;
+ return 0;
+}
+
+int sceFontRenderCharGlyphImageHorizontal(FontHandle font_handle, uint32_t code, FontRenderSurface* surf, float x, float y, FontGlyphMetrics* metrics, FontRenderResult* result) {
+ (void)font_handle;
+ (void)code;
+ (void)surf;
+ (void)x;
+ (void)y;
+ (void)metrics;
+ (void)result;
+ return 0;
+}
+
+void sceFontRenderSurfaceInit(FontRenderSurface* surf, void* buffer, int buf_width_byte, int pixel_size_byte, int width, int height) {
+ (void)surf;
+ (void)buffer;
+ (void)buf_width_byte;
+ (void)pixel_size_byte;
+ (void)width;
+ (void)height;
+}
+
+void sceFontRenderSurfaceSetScissor(FontRenderSurface* surf, uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1) {
+ (void)surf;
+ (void)x0;
+ (void)y0;
+ (void)x1;
+ (void)y1;
+}
+
+int sceFontSetEffectSlant(FontHandle font_handle, float slant_ratio) {
+ (void)font_handle;
+ (void)slant_ratio;
+ return 0;
+}
+
+int sceFontSetEffectWeight(FontHandle font_handle, float weight_x_scale, float weight_y_scale, uint32_t mode) {
+ (void)font_handle;
+ (void)weight_x_scale;
+ (void)weight_y_scale;
+ (void)mode;
+ return 0;
+}
+
+int sceFontSetScalePixel(FontHandle font_handle, float w, float h) {
+ (void)font_handle;
+ (void)w;
+ (void)h;
+ return 0;
+}
+
+int sceFontSetupRenderEffectSlant(FontHandle font_handle, float slant_ratio) {
+ (void)font_handle;
+ (void)slant_ratio;
+ return 0;
+}
+
+int sceFontSetupRenderEffectWeight(FontHandle font_handle, float weight_x_scale, float weight_y_scale, uint32_t mode) {
+ (void)font_handle;
+ (void)weight_x_scale;
+ (void)weight_y_scale;
+ (void)mode;
+ return 0;
+}
+
+int sceFontSetupRenderScalePixel(FontHandle font_handle, float w, float h) {
+ (void)font_handle;
+ (void)w;
+ (void)h;
+ return 0;
+}
+
+uint32_t sceFontStringGetTerminateCode(FontString font_string) {
+ (void)font_string;
+ return 0;
+}
+
+void* sceFontStringGetTerminateOrder(FontString font_string) {
+ (void)font_string;
+ return nullptr;
+}
+
+int sceFontStringGetWritingForm(FontString font_string) {
+ (void)font_string;
+ return 0;
+}
+
+FontRenderCharacter sceFontStringRefersRenderCharacters(FontString font_string, FontTextCharacter start_character, FontTextCharacter last_character, uint32_t* character_count) {
+ (void)font_string;
+ (void)start_character;
+ (void)last_character;
+ (void)character_count;
+ return {};
+}
+
+FontTextCharacter sceFontStringRefersTextCharacters(FontString font_string, uint32_t* character_count) {
+ (void)font_string;
+ (void)character_count;
+ return {};
+}
+
+int sceFontSupportExternalFonts(FontLibrary library, uint32_t font_max, uint32_t formats) {
+ (void)library;
+ (void)font_max;
+ (void)formats;
+ return 0;
+}
+
+int sceFontSupportSystemFonts(FontLibrary library) {
+ (void)library;
+ return 0;
+}
+
+FontTextCodes* sceFontTextCodesStepBack(FontTextCodes* text_codes_step) {
+ (void)text_codes_step;
+ return nullptr;
+}
+
+FontTextCodes* sceFontTextCodesStepNext(FontTextCodes* text_codes_step) {
+ (void)text_codes_step;
+ return nullptr;
+}
+
+int sceFontTextSourceInit(FontTextSource* font_text_source, const void* text_address, uint32_t text_size_byte, FontTextParseFunction text_parser, void* text_object) {
+ (void)font_text_source;
+ (void)text_address;
+ (void)text_size_byte;
+ (void)text_parser;
+ (void)text_object;
+ return 0;
+}
+
+int sceFontTextSourceRewind(FontTextSource* font_text_source) {
+ (void)font_text_source;
+ return 0;
+}
+
+int sceFontTextSourceSetDefaultFont(FontTextSource* font_text_source, FontHandle default_font) {
+ (void)font_text_source;
+ (void)default_font;
+ return 0;
+}
+
+int sceFontTextSourceSetWritingForm(FontTextSource* font_text_source, int writing_form) {
+ (void)font_text_source;
+ (void)writing_form;
+ return 0;
+}
+
+int sceFontUnbindRenderer(FontHandle font_handle) {
+ (void)font_handle;
+ return 0;
+}
+
+int sceFontWritingGetRenderMetrics(FontWriting* font_writing, FontWritingMetrics* writing_metrics) {
+ (void)font_writing;
+ (void)writing_metrics;
+ return 0;
+}
+
+int sceFontWritingInit(FontWriting* font_writing, FontString font_string, FontRenderCharacter font_character) {
+ (void)font_writing;
+ (void)font_string;
+ (void)font_character;
+ return 0;
+}
+
+int sceFontWritingLineClear(FontWritingLine writing_line) {
+ (void)writing_line;
+ return 0;
+}
+
+int sceFontWritingLineGetOrderingSpace(FontWritingLine writing_line, float* head_space, float* inline_space, float* tail_space, float* advance_space) {
+ (void)writing_line;
+ (void)head_space;
+ (void)inline_space;
+ (void)tail_space;
+ (void)advance_space;
+ return 0;
+}
+
+int sceFontWritingLineGetRenderMetrics(FontWritingLine writing_line, FontWritingMetrics* writing_metrics) {
+ (void)writing_line;
+ (void)writing_metrics;
+ return 0;
+}
+
+FontWritingLineStep* sceFontWritingLineRefersRenderStep(FontWritingLine writing_line) {
+ (void)writing_line;
+ return nullptr;
+}
+
+int sceFontWritingLineWritesOrder(FontWritingLine writing_line, uint64_t writing_attribute, const FontWritingMetrics* writing_metrics, void* writing_orderer) {
+ (void)writing_line;
+ (void)writing_attribute;
+ (void)writing_metrics;
+ (void)writing_orderer;
+ return 0;
+}
+
+const FontWritingStep* sceFontWritingRefersRenderStep(FontWriting* font_writing) {
+ (void)font_writing;
+ return nullptr;
+}
+
+FontTextCharacter sceFontWritingRefersRenderStepCharacter(FontWriting* font_writing, const void** letter_step) {
+ (void)font_writing;
+ (void)letter_step;
+ return {};
+}
+
+int sceFontWritingSetMaskInvisible(FontWriting* font_writing, int mask) {
+ (void)font_writing;
+ (void)mask;
+ return 0;
+}
+
+}

core/libs/prx/libSceFontFt/Export.cpp

@@ -0,0 +1,17 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+void* sceFontSelectLibraryFt(int value) {
+ (void)value;
+ return nullptr;
+}
+
+void* sceFontSelectRendererFt(int value) {
+ (void)value;
+ return nullptr;
+}
+
+}

core/libs/prx/libSceGameLiveStreaming/Export.cpp

@@ -0,0 +1,16 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceGameLiveStreamingInitialize(size_t heap_size) {
+ (void)heap_size;
+ return 0;
+}
+
+int sceGameLiveStreamingTerminate(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceGameUpdate/Export.cpp

@@ -0,0 +1,43 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceGameUpdateAbortRequest(int request_id) {
+ (void)request_id;
+ return 0;
+}
+
+int sceGameUpdateCheck(int request_id, const GameUpdateCheckParam* param, GameUpdateCheckResult* result) {
+ (void)request_id;
+ (void)param;
+ (void)result;
+ return 0;
+}
+
+int sceGameUpdateCreateRequest(void) {
+ return 0;
+}
+
+int sceGameUpdateDeleteRequest(int request_id) {
+ (void)request_id;
+ return 0;
+}
+
+int sceGameUpdateGetAddcontLatestVersion(uint32_t service_label, const void* entitlement_label, GameUpdateAddcontVersionInfo* info) {
+ (void)service_label;
+ (void)entitlement_label;
+ (void)info;
+ return 0;
+}
+
+int sceGameUpdateInitialize(void) {
+ return 0;
+}
+
+int sceGameUpdateTerminate(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceHttp/Export.cpp

@@ -0,0 +1,245 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceHttpAbortRequest(int request_id) {
+ (void)request_id;
+ return 0;
+}
+
+int sceHttpAddRequestHeader(int id, const char* name, const char* value, uint32_t mode) {
+ (void)id;
+ (void)name;
+ (void)value;
+ (void)mode;
+ return 0;
+}
+
+int sceHttpCreateConnection(int tmpl_id, const char* server_name, const char* scheme, uint16_t port, int enable_keep_alive) {
+ (void)tmpl_id;
+ (void)server_name;
+ (void)scheme;
+ (void)port;
+ (void)enable_keep_alive;
+ return 0;
+}
+
+int sceHttpCreateConnectionWithURL(int tmpl_id, const char* url, int enable_keep_alive) {
+ (void)tmpl_id;
+ (void)url;
+ (void)enable_keep_alive;
+ return 0;
+}
+
+int sceHttpCreateEpoll(int http_ctx_id, HttpEpollHandle* eh) {
+ (void)http_ctx_id;
+ (void)eh;
+ return 0;
+}
+
+int sceHttpCreateRequest(int conn_id, int method, const char* path, uint64_t content_length) {
+ (void)conn_id;
+ (void)method;
+ (void)path;
+ (void)content_length;
+ return 0;
+}
+
+int sceHttpCreateRequestWithURL2(int conn_id, const char* method, const char* url, uint64_t content_length) {
+ (void)conn_id;
+ (void)method;
+ (void)url;
+ (void)content_length;
+ return 0;
+}
+
+int sceHttpCreateTemplate(int http_ctx_id, const char* user_agent, int http_ver, int is_auto_proxy_conf) {
+ (void)http_ctx_id;
+ (void)user_agent;
+ (void)http_ver;
+ (void)is_auto_proxy_conf;
+ return 0;
+}
+
+int sceHttpDeleteConnection(int conn_id) {
+ (void)conn_id;
+ return 0;
+}
+
+int sceHttpDeleteRequest(int req_id) {
+ (void)req_id;
+ return 0;
+}
+
+int sceHttpDeleteTemplate(int tmpl_id) {
+ (void)tmpl_id;
+ return 0;
+}
+
+int sceHttpDestroyEpoll(int http_ctx_id, HttpEpollHandle eh) {
+ (void)http_ctx_id;
+ (void)eh;
+ return 0;
+}
+
+int sceHttpGetAllResponseHeaders(int request_id, char** header, size_t* header_size) {
+ (void)request_id;
+ (void)header;
+ (void)header_size;
+ return 0;
+}
+
+int sceHttpGetResponseContentLength(int request_id, int* result, uint64_t* content_length) {
+ (void)request_id;
+ (void)result;
+ (void)content_length;
+ return 0;
+}
+
+int sceHttpGetStatusCode(int request_id, int* status_code) {
+ (void)request_id;
+ (void)status_code;
+ return 0;
+}
+
+int sceHttpInit(int memid, int ssl_ctx_id, uint64_t pool_size) {
+ (void)memid;
+ (void)ssl_ctx_id;
+ (void)pool_size;
+ return 0;
+}
+
+int sceHttpsDisableOption(int id, uint32_t ssl_flags) {
+ (void)id;
+ (void)ssl_flags;
+ return 0;
+}
+
+int sceHttpSendRequest(int request_id, const void* post_data, size_t size) {
+ (void)request_id;
+ (void)post_data;
+ (void)size;
+ return 0;
+}
+
+int sceHttpSetAuthEnabled(int id, int enable) {
+ (void)id;
+ (void)enable;
+ return 0;
+}
+
+int sceHttpSetAutoRedirect(int id, int enable) {
+ (void)id;
+ (void)enable;
+ return 0;
+}
+
+int sceHttpSetConnectTimeOut(int id, uint32_t usec) {
+ (void)id;
+ (void)usec;
+ return 0;
+}
+
+int sceHttpSetEpoll(int id, HttpEpollHandle eh, void* user_arg) {
+ (void)id;
+ (void)eh;
+ (void)user_arg;
+ return 0;
+}
+
+int sceHttpSetNonblock(int id, int enable) {
+ (void)id;
+ (void)enable;
+ return 0;
+}
+
+int sceHttpSetRecvTimeOut(int id, uint32_t usec) {
+ (void)id;
+ (void)usec;
+ return 0;
+}
+
+int sceHttpSetRequestContentLength(int request_id, uint64_t content_length) {
+ (void)request_id;
+ (void)content_length;
+ return 0;
+}
+
+int sceHttpSetResolveRetry(int id, int32_t retry) {
+ (void)id;
+ (void)retry;
+ return 0;
+}
+
+int sceHttpSetResolveTimeOut(int id, uint32_t usec) {
+ (void)id;
+ (void)usec;
+ return 0;
+}
+
+int sceHttpSetSendTimeOut(int id, uint32_t usec) {
+ (void)id;
+ (void)usec;
+ return 0;
+}
+
+int sceHttpsSetMinSslVersion(int id, uint32_t ssl_version) {
+ (void)id;
+ (void)ssl_version;
+ return 0;
+}
+
+int sceHttpsSetSslCallback(int id, HttpsCallback cbfunc, void* user_arg) {
+ (void)id;
+ (void)cbfunc;
+ (void)user_arg;
+ return 0;
+}
+
+int sceHttpTerm(int http_ctx_id) {
+ (void)http_ctx_id;
+ return 0;
+}
+
+int sceHttpUnsetEpoll(int id) {
+ (void)id;
+ return 0;
+}
+
+int sceHttpUriBuild(char* out, size_t* require, size_t prepare, const SceHttpUriElement* src_element, uint32_t option) {
+ (void)out;
+ (void)require;
+ (void)prepare;
+ (void)src_element;
+ (void)option;
+ return 0;
+}
+
+int sceHttpUriEscape(char* out, size_t* require, size_t prepare, const char* in) {
+ (void)out;
+ (void)require;
+ (void)prepare;
+ (void)in;
+ return 0;
+}
+
+int sceHttpUriParse(SceHttpUriElement* out, const char* src_url, void* pool, size_t* require, size_t prepare) {
+ (void)out;
+ (void)src_url;
+ (void)pool;
+ (void)require;
+ (void)prepare;
+ return 0;
+}
+
+int sceHttpWaitRequest(HttpEpollHandle eh, HttpNBEvent* nbev, int maxevents, int timeout) {
+ (void)eh;
+ (void)nbev;
+ (void)maxevents;
+ (void)timeout;
+ return 0;
+}
+
+}

core/libs/prx/libSceHttp2/Export.cpp

@@ -0,0 +1,201 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceHttp2AddRequestHeader(int id, const char* name, const char* value, uint32_t mode) {
+ (void)id;
+ (void)name;
+ (void)value;
+ (void)mode;
+ return 0;
+}
+
+int sceHttp2CreateRequestWithURL(int tmpl_id, const char* method, const char* url, uint64_t content_length) {
+ (void)tmpl_id;
+ (void)method;
+ (void)url;
+ (void)content_length;
+ return 0;
+}
+
+int sceHttp2CreateTemplate(int lib_http2_ctx_id, const char* user_agent, int http_ver, int is_auto_proxy_conf) {
+ (void)lib_http2_ctx_id;
+ (void)user_agent;
+ (void)http_ver;
+
+ (void)is_auto_proxy_conf;
+ return 0;
+}
+
+int sceHttp2DeleteRequest(int req_id) {
+ (void)req_id;
+ return 0;
+}
+
+int sceHttp2DeleteTemplate(int tmpl_id) {
+ (void)tmpl_id;
+ return 0;
+}
+
+int sceHttp2GetAllResponseHeaders(int req_id, char** header, size_t* header_size) {
+ (void)req_id;
+ (void)header;
+ (void)header_size;
+ return 0;
+}
+
+int sceHttp2GetResponseContentLength(int req_id, int* result, uint64_t* content_length) {
+ (void)req_id;
+ (void)result;
+ (void)content_length;
+ return 0;
+}
+
+int sceHttp2GetStatusCode(int req_id, int* status_code) {
+ (void)req_id;
+ (void)status_code;
+ return 0;
+}
+
+int sceHttp2Init(int libnet_mem_id, int libssl_ctx_id, size_t pool_size, int max_concurrent_request) {
+ (void)libnet_mem_id;
+ (void)libssl_ctx_id;
+ (void)pool_size;
+ (void)max_concurrent_request;
+ return 0;
+}
+
+int sceHttp2ReadData(int req_id, void* data, size_t size) {
+ (void)req_id;
+ (void)data;
+ (void)size;
+ return 0;
+}
+
+int sceHttp2ReadDataAsync(int req_id, void* data, size_t size, void* kqueue_option, void* option) {
+ (void)req_id;
+ (void)data;
+ (void)size;
+ (void)kqueue_option;
+ (void)option;
+ return 0;
+}
+
+int sceHttp2SendRequest(int req_id, const void* post_data, size_t size) {
+ (void)req_id;
+ (void)post_data;
+ (void)size;
+ return 0;
+}
+
+int sceHttp2SendRequestAsync(int req_id, const void* post_data, size_t size, void* kqueue_option, void* option) {
+ (void)req_id;
+ (void)post_data;
+ (void)size;
+ (void)kqueue_option;
+ (void)option;
+ return 0;
+}
+
+int sceHttp2SetAuthEnabled(int id, int is_enable) {
+ (void)id;
+ (void)is_enable;
+ return 0;
+}
+
+int sceHttp2SetAutoRedirect(int id, int enable) {
+ (void)id;
+ (void)enable;
+ return 0;
+}
+
+int sceHttp2SetConnectionWaitTimeOut(int id, uint32_t usec) {
+ (void)id;
+ (void)usec;
+ return 0;
+}
+
+int sceHttp2SetConnectTimeOut(int id, uint32_t usec) {
+ (void)id;
+ (void)usec;
+ return 0;
+}
+
+int sceHttp2SetInflateGZIPEnabled(int id, int enable) {
+ (void)id;
+ (void)enable;
+ return 0;
+}
+
+int sceHttp2SetRecvTimeOut(int id, uint32_t usec) {
+ (void)id;
+ (void)usec;
+ return 0;
+}
+
+int sceHttp2SetRedirectCallback(int id, void* cb_func, void* user_arg) {
+ (void)id;
+ (void)cb_func;
+ (void)user_arg;
+ return 0;
+}
+
+int sceHttp2SetRequestContentLength(int id, uint64_t content_length) {
+ (void)id;
+ (void)content_length;
+ return 0;
+}
+
+int sceHttp2SetResolveTimeOut(int id, uint32_t usec) {
+ (void)id;
+ (void)usec;
+ return 0;
+}
+
+int sceHttp2SetSendTimeOut(int id, uint32_t usec) {
+ (void)id;
+ (void)usec;
+ return 0;
+}
+
+int sceHttp2SetSslCallback(int id, void* cb_func, void* user_arg) {
+ (void)id;
+ (void)cb_func;
+ (void)user_arg;
+ return 0;
+}
+
+int sceHttp2SetTimeOut(int id, uint32_t usec) {
+ (void)id;
+ (void)usec;
+ return 0;
+}
+
+int sceHttp2SslDisableOption(int id, uint32_t ssl_flags) {
+ (void)id;
+ (void)ssl_flags;
+ return 0;
+}
+
+int sceHttp2SslEnableOption(int id, uint32_t ssl_flags) {
+ (void)id;
+ (void)ssl_flags;
+ return 0;
+}
+
+int sceHttp2Term(int lib_http2_ctx_id) {
+ (void)lib_http2_ctx_id;
+ return 0;
+}
+
+int sceHttp2WaitAsync(int req_id, Http2AsyncResult* result, uint32_t* timeout, void* option) {
+ (void)req_id;
+ (void)result;
+ (void)timeout;
+ (void)option;
+ return 0;
+}
+
+}

core/libs/prx/libSceIme/Export.cpp

@@ -0,0 +1,79 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceImeClose(void) {
+ return 0;
+}
+
+int sceImeGetPanelSize(const Param* param, uint32_t* width, uint32_t* height) {
+ (void)param;
+ (void)width;
+ (void)height;
+ return 0;
+}
+
+int sceImeKeyboardClose(int32_t user_id) {
+ (void)user_id;
+ return 0;
+}
+
+int sceImeKeyboardGetInfo(uint32_t resource_id, KeyboardInfo* info) {
+ (void)resource_id;
+ (void)info;
+ return 0;
+}
+
+int sceImeKeyboardGetResourceId(int32_t user_id, KeyboardResourceIdArray* resource_ids) {
+ (void)user_id;
+ (void)resource_ids;
+ return 0;
+}
+
+int sceImeKeyboardOpen(int32_t user_id, const KeyboardParam* param) {
+ (void)user_id;
+ (void)param;
+ return 0;
+}
+
+int sceImeKeyboardSetMode(int32_t user_id, uint32_t mode) {
+ (void)user_id;
+ (void)mode;
+ return 0;
+}
+
+int sceImeOpen(const Param* param, const ExtendedParam* extended) {
+ (void)param;
+ (void)extended;
+ return 0;
+}
+
+void sceImeParamInit(Param* param) {
+ (void)param;
+}
+
+int sceImeSetCaret(const Caret* caret) {
+ (void)caret;
+ return 0;
+}
+
+int sceImeSetText(const char16_t* text, uint32_t length) {
+ (void)text;
+ (void)length;
+ return 0;
+}
+
+int sceImeSetTextGeometry(TextAreaMode mode, const TextGeometry* geometry) {
+ (void)mode;
+ (void)geometry;
+ return 0;
+}
+
+int sceImeUpdate(EventHandler handler) {
+ (void)handler;
+ return 0;
+}
+
+}

core/libs/prx/libSceImeDialog/Export.cpp

@@ -0,0 +1,50 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceImeDialogAbort(void) {
+ return 0;
+}
+
+int sceImeDialogGetPanelPositionAndForm(PositionAndForm* form) {
+ (void)form;
+ return 0;
+}
+
+int sceImeDialogGetPanelSize(const Param* param, uint32_t* width, uint32_t* height) {
+ (void)param;
+ (void)width;
+ (void)height;
+ return 0;
+}
+
+int sceImeDialogGetPanelSizeExtended(const Param* param, const ExtendedParam* extended, uint32_t* width, uint32_t* height) {
+ (void)param;
+ (void)extended;
+ (void)width;
+ (void)height;
+ return 0;
+}
+
+int sceImeDialogGetResult(Result* result) {
+ (void)result;
+ return 0;
+}
+
+int sceImeDialogGetStatus(void) {
+ return 0;
+}
+
+int sceImeDialogInit(const Param* param, const ExtendedParam* extended) {
+ (void)param;
+ (void)extended;
+ return 0;
+}
+
+int sceImeDialogTerm(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceKeyboard/Export.cpp

@@ -0,0 +1,47 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceKeyboardClose(int32_t handle) {
+ (void)handle;
+ return 0;
+}
+
+int sceKeyboardGetKey2Char(int32_t handle, int32_t arrange, uint32_t led, uint32_t modifier_key, uint16_t key_code, KeyboardCharData* char_data) {
+ (void)handle;
+ (void)arrange;
+ (void)led;
+ (void)modifier_key;
+ (void)key_code;
+ (void)char_data;
+ return 0;
+}
+
+int sceKeyboardInit(void) {
+ return 0;
+}
+
+int sceKeyboardOpen(int user_id, int32_t type, int32_t index, const void* param) {
+ (void)user_id;
+ (void)type;
+ (void)index;
+ (void)param;
+ return 0;
+}
+
+int sceKeyboardRead(int32_t handle, KeyboardData* data, int32_t num) {
+ (void)handle;
+ (void)data;
+ (void)num;
+ return 0;
+}
+
+int sceKeyboardReadState(int32_t handle, KeyboardData* data) {
+ (void)handle;
+ (void)data;
+ return 0;
+}
+
+}

core/libs/prx/libSceLibcInternal/Export.cpp

@@ -0,0 +1,210 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+[[noreturn]] void abort(uint64_t arg0, uint64_t arg1, uint64_t arg2, uint64_t arg3, uint64_t arg4, uint64_t arg5) {
+ (void)arg0;
+ (void)arg1;
+ (void)arg2;
+ (void)arg3;
+ (void)arg4;
+ (void)arg5;
+ __builtin_unreachable();
+}
+
+int atexit(atexit_func_t func) {
+ (void)func;
+ return 0;
+}
+
+int atoi(const char* str) {
+ (void)str;
+ return 0;
+}
+
+double cos(double x) {
+ (void)x;
+ return 0;
+}
+
+float cosf(float x) {
+ (void)x;
+ return 0;
+}
+
+void Exit(int code) {
+ (void)code;
+}
+
+void exit(int code) {
+ (void)code;
+}
+
+int fflush(FILE* stream) {
+ (void)stream;
+ return 0;
+}
+
+void init_env(const InitEnvParams* params) {
+ (void)params;
+}
+
+int memcmp(const void* s1, const void* s2, size_t n) {
+ (void)s1;
+ (void)s2;
+ (void)n;
+ return 0;
+}
+
+void* memcpy(void* dest, const void* src, size_t n) {
+ (void)dest;
+ (void)src;
+ (void)n;
+ return nullptr;
+}
+
+void* memmove(void* dest, const void* src, size_t n) {
+ (void)dest;
+ (void)src;
+ (void)n;
+ return nullptr;
+}
+
+void* memset(void* s, int c, size_t n) {
+ (void)s;
+ (void)c;
+ (void)n;
+ return nullptr;
+}
+
+int puts(const char* s) {
+ (void)s;
+ return 0;
+}
+
+void sceLibcHeapGetTraceInfo(Info* info) {
+ (void)info;
+}
+
+int setenv(const char* name, const char* value, int overwrite) {
+ (void)name;
+ (void)value;
+ (void)overwrite;
+ return 0;
+}
+
+double Sin(double x) {
+ (void)x;
+ return 0;
+}
+
+double sin(double x) {
+ (void)x;
+ return 0;
+}
+
+void Sincos(double x, double* sinp, double* cosp) {
+ (void)x;
+ (void)sinp;
+ (void)cosp;
+}
+
+void sincos(double x, double* sinp, double* cosp) {
+ (void)x;
+ (void)sinp;
+ (void)cosp;
+}
+
+void sincosf(float x, float* sinp, float* cosp) {
+ (void)x;
+ (void)sinp;
+ (void)cosp;
+}
+
+float sinf(float x) {
+ (void)x;
+ return 0;
+}
+
+int snprintf(VA_ARGS) {
+ return 0;
+}
+
+char* strcat(char* dest, const char* src) {
+ (void)dest;
+ (void)src;
+ return nullptr;
+}
+
+const char* strchr(const char* s, int c) {
+ (void)s;
+ (void)c;
+ return nullptr;
+}
+
+int strcmp(const char* s1, const char* s2) {
+ (void)s1;
+ (void)s2;
+ return 0;
+}
+
+char* strcpy(char* dest, const char* src) {
+ (void)dest;
+ (void)src;
+ return nullptr;
+}
+
+size_t strlen(const char* s) {
+ (void)s;
+ return 0;
+}
+
+int strncmp(const char* s1, const char* s2, size_t n) {
+ (void)s1;
+ (void)s2;
+ (void)n;
+ return 0;
+}
+
+char* strncpy(char* dest, const char* src, size_t count) {
+ (void)dest;
+ (void)src;
+ (void)count;
+ return nullptr;
+}
+
+char* strrchr(const char* s, int c) {
+ (void)s;
+ (void)c;
+ return nullptr;
+}
+
+char* strstr(const char* haystack, const char* needle) {
+ (void)haystack;
+ (void)needle;
+ return nullptr;
+}
+
+long strtol(const char* str, char** endptr, int base) {
+ (void)str;
+ (void)endptr;
+ (void)base;
+ return 0;
+}
+
+unsigned long strtoul(const char* str, char** endptr, int base) {
+ (void)str;
+ (void)endptr;
+ (void)base;
+ return 0;
+}
+
+int vprintf(const char* str, VaList* c) {
+ (void)str;
+ (void)c;
+ return 0;
+}
+
+}

core/libs/prx/libSceLoginDialog/Export.cpp

@@ -0,0 +1,37 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceLoginDialogClose(void) {
+ return 0;
+}
+
+int sceLoginDialogGetResult(void* result) {
+ (void)result;
+ return 0;
+}
+
+int sceLoginDialogGetStatus(void) {
+ return 0;
+}
+
+int sceLoginDialogInitialize(void) {
+ return 0;
+}
+
+int sceLoginDialogOpen(const void* param) {
+ (void)param;
+ return 0;
+}
+
+int sceLoginDialogTerminate(void) {
+ return 0;
+}
+
+int sceLoginDialogUpdateStatus(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceMouse/Export.cpp

@@ -0,0 +1,31 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceMouseClose(int32_t handle) {
+ (void)handle;
+ return 0;
+}
+
+int sceMouseInit(void) {
+ return 0;
+}
+
+int sceMouseOpen(int user_id, int32_t type, int32_t index, const void* param) {
+ (void)user_id;
+ (void)type;
+ (void)index;
+ (void)param;
+ return 0;
+}
+
+int sceMouseRead(int32_t handle, MouseData* data, int32_t num) {
+ (void)handle;
+ (void)data;
+ (void)num;
+ return 0;
+}
+
+}

core/libs/prx/libSceMsgDialog/Export.cpp

@@ -0,0 +1,55 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceMsgDialogClose(void) {
+ return 0;
+}
+
+int sceMsgDialogGetResult(void* result) {
+ (void)result;
+ return 0;
+}
+
+int sceMsgDialogGetStatus(void) {
+ return 0;
+}
+
+int sceMsgDialogInitialize(void) {
+ return 0;
+}
+
+int sceMsgDialogOpen(const void* param) {
+ (void)param;
+ return 0;
+}
+
+int sceMsgDialogProgressBarInc(int target, uint32_t delta) {
+ (void)target;
+ (void)delta;
+ return 0;
+}
+
+int sceMsgDialogProgressBarSetMsg(int target, const char* msg) {
+ (void)target;
+ (void)msg;
+ return 0;
+}
+
+int sceMsgDialogProgressBarSetValue(int target, uint32_t rate) {
+ (void)target;
+ (void)rate;
+ return 0;
+}
+
+int sceMsgDialogTerminate(void) {
+ return 0;
+}
+
+int sceMsgDialogUpdateStatus(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceNet/Export.cpp

@@ -0,0 +1,178 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceNetAccept(int s, void* addr, uint32_t* addrlen) {
+ (void)s;
+ (void)addr;
+ (void)addrlen;
+ return 0;
+}
+
+int sceNetBind(int s, const void* addr, uint32_t addrlen) {
+ (void)s;
+ (void)addr;
+ (void)addrlen;
+ return 0;
+}
+
+int sceNetEpollControl(int eid, int op, int id, const NetEpollEvent* event) {
+ (void)eid;
+ (void)op;
+ (void)id;
+ (void)event;
+ return 0;
+}
+
+int sceNetEpollCreate(const char* name, int flags) {
+ (void)name;
+ (void)flags;
+ return 0;
+}
+
+int sceNetEpollDestroy(int eid) {
+ (void)eid;
+ return 0;
+}
+
+int sceNetEpollWait(int eid, NetEpollEvent* events, int maxevents, int timeout) {
+ (void)eid;
+ (void)events;
+ (void)maxevents;
+ (void)timeout;
+ return 0;
+}
+
+int sceNetEtherNtostr(const NetEtherAddr* n, char* str, size_t len) {
+ (void)n;
+ (void)str;
+ (void)len;
+ return 0;
+}
+
+int sceNetGetMacAddress(NetEtherAddr* addr, int flags) {
+ (void)addr;
+ (void)flags;
+ return 0;
+}
+
+int sceNetGetSockInfo(int s, void* info, int n, int flags) {
+ (void)s;
+ (void)info;
+ (void)n;
+ (void)flags;
+ return 0;
+}
+
+int sceNetGetsockname(int s, void* addr, uint32_t* addrlen) {
+ (void)s;
+ (void)addr;
+ (void)addrlen;
+ return 0;
+}
+
+uint32_t sceNetHtonl(uint32_t host32) {
+ (void)host32;
+ return 0;
+}
+
+uint16_t sceNetHtons(uint16_t host16) {
+ (void)host16;
+ return 0;
+}
+
+const char* sceNetInetNtop(int af, const void* src, char* dst, uint32_t size) {
+ (void)af;
+ (void)src;
+ (void)dst;
+ (void)size;
+ return nullptr;
+}
+
+int sceNetInetPton(int af, const char* src, void* dst) {
+ (void)af;
+ (void)src;
+ (void)dst;
+ return 0;
+}
+
+int sceNetInit(void) {
+ return 0;
+}
+
+int sceNetListen(int s, int backlog) {
+ (void)s;
+ (void)backlog;
+ return 0;
+}
+
+uint32_t sceNetNtohl(uint32_t net32) {
+ (void)net32;
+ return 0;
+}
+
+uint16_t sceNetNtohs(uint16_t net16) {
+ (void)net16;
+ return 0;
+}
+
+int sceNetPoolCreate(const char* name, int size, int flags) {
+ (void)name;
+ (void)size;
+ (void)flags;
+ return 0;
+}
+
+int sceNetPoolDestroy(int memid) {
+ (void)memid;
+ return 0;
+}
+
+int sceNetResolverCreate(const char* name, int memid, int flags) {
+ (void)name;
+ (void)memid;
+ (void)flags;
+ return 0;
+}
+
+int sceNetResolverStartNtoa(int rid, const char* hostname, void* addr, int timeout, int retry, int flags) {
+ (void)rid;
+ (void)hostname;
+ (void)addr;
+ (void)timeout;
+ (void)retry;
+ (void)flags;
+ return 0;
+}
+
+int sceNetSetsockopt(int s, int level, int optname, const void* optval, uint32_t optlen) {
+ (void)s;
+ (void)level;
+ (void)optname;
+ (void)optval;
+ (void)optlen;
+ return 0;
+}
+
+int sceNetShutdown(int s, int how) {
+ (void)s;
+ (void)how;
+ return 0;
+}
+
+int sceNetSocket(const char* name, int family, int type, int protocol) {
+ (void)name;
+ (void)family;
+ (void)type;
+ (void)protocol;
+ return 0;
+}
+
+int sceNetSocketClose(int s) {
+ (void)s;
+ return 0;
+}
+
+}

core/libs/prx/libSceNetCtl/Export.cpp

@@ -0,0 +1,57 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceNetCtlCheckCallback(void) {
+ return 0;
+}
+
+int sceNetCtlGetInfo(int code, NetCtlInfo* info) {
+ (void)code;
+ (void)info;
+ return 0;
+}
+
+int sceNetCtlGetNatInfo(NetCtlNatInfo* nat_info) {
+ (void)nat_info;
+ return 0;
+}
+
+int sceNetCtlGetResult(int event_type, int* error_code) {
+ (void)event_type;
+ (void)error_code;
+ return 0;
+}
+
+int sceNetCtlGetState(int* state) {
+ (void)state;
+ return 0;
+}
+
+int sceNetCtlGetStateV6(int* state) {
+ (void)state;
+ return 0;
+}
+
+int sceNetCtlInit(void) {
+ return 0;
+}
+
+int sceNetCtlRegisterCallback(NetCtlCallback func, void* arg, int* cid) {
+ (void)func;
+ (void)arg;
+ (void)cid;
+ return 0;
+}
+
+void sceNetCtlTerm(void) {
+}
+
+int sceNetCtlUnregisterCallback(int cid) {
+ (void)cid;
+ return 0;
+}
+
+}

core/libs/prx/libSceNgs2.native/Export.cpp

@@ -0,0 +1,190 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceNgs2CalcWaveformBlock(const Ngs2WaveformFormat* format, uint32_t sample_pos, uint32_t num_samples, Ngs2WaveformBlock* block) {
+ (void)format;
+ (void)sample_pos;
+ (void)num_samples;
+ (void)block;
+ return 0;
+}
+
+int sceNgs2GeomApply(const Ngs2GeomListenerWork* listener, const Ngs2GeomSourceParam* source, Ngs2GeomAttribute* out_attrib, uint32_t flags) {
+ (void)listener;
+ (void)source;
+ (void)out_attrib;
+ (void)flags;
+ return 0;
+}
+
+int sceNgs2GeomCalcListener(const Ngs2GeomListenerParam* param, Ngs2GeomListenerWork* out_work, uint32_t flags) {
+ (void)param;
+ (void)out_work;
+ (void)flags;
+ return 0;
+}
+
+int sceNgs2GeomResetListenerParam(Ngs2GeomListenerParam* out_listener_param) {
+ (void)out_listener_param;
+ return 0;
+}
+
+int sceNgs2GeomResetSourceParam(Ngs2GeomSourceParam* out_source_param) {
+ (void)out_source_param;
+ return 0;
+}
+
+int sceNgs2PanGetVolumeMatrix(Ngs2PanWork* work, const Ngs2PanParam* params, uint32_t num_params, uint32_t matrix_format, float* out_volume_matrix) {
+ (void)work;
+ (void)params;
+ (void)num_params;
+ (void)matrix_format;
+ (void)out_volume_matrix;
+ return 0;
+}
+
+int sceNgs2PanInit(Ngs2PanWork* work, const float* speaker_angles, float unit_angle, uint32_t num_speakers) {
+ (void)work;
+ (void)speaker_angles;
+ (void)unit_angle;
+ (void)num_speakers;
+ return 0;
+}
+
+int sceNgs2ParseWaveformData(const void* data, size_t data_size, Ngs2WaveformInfo* info) {
+ (void)data;
+ (void)data_size;
+ (void)info;
+ return 0;
+}
+
+int sceNgs2RackCreate(uintptr_t system_handle, uint32_t rack_id, const Ngs2RackOption* option, const Ngs2ContextBufferInfo* buffer_info, uintptr_t* handle) {
+ (void)system_handle;
+ (void)rack_id;
+ (void)option;
+ (void)buffer_info;
+ (void)handle;
+ return 0;
+}
+
+int sceNgs2RackCreateWithAllocator(uintptr_t system_handle, uint32_t rack_id, const Ngs2RackOption* option, const Ngs2BufferAllocator* allocator, uintptr_t* handle) {
+ (void)system_handle;
+ (void)rack_id;
+ (void)option;
+ (void)allocator;
+ (void)handle;
+ return 0;
+}
+
+int sceNgs2RackDestroy(uintptr_t rack_handle, Ngs2ContextBufferInfo* buffer_info) {
+ (void)rack_handle;
+ (void)buffer_info;
+ return 0;
+}
+
+int sceNgs2RackGetVoiceHandle(uintptr_t rack_handle, uint32_t voice_id, uintptr_t* handle) {
+ (void)rack_handle;
+ (void)voice_id;
+ (void)handle;
+ return 0;
+}
+
+int sceNgs2RackLock(uintptr_t rack_handle) {
+ (void)rack_handle;
+ return 0;
+}
+
+int sceNgs2RackQueryBufferSize(uint32_t rack_id, const Ngs2RackOption* option, Ngs2ContextBufferInfo* buffer_info) {
+ (void)rack_id;
+ (void)option;
+ (void)buffer_info;
+ return 0;
+}
+
+int sceNgs2RackUnlock(uintptr_t rack_handle) {
+ (void)rack_handle;
+ return 0;
+}
+
+int sceNgs2SystemCreate(const Ngs2SystemOption* option, const Ngs2ContextBufferInfo* buffer_info, uintptr_t* handle) {
+ (void)option;
+ (void)buffer_info;
+ (void)handle;
+ return 0;
+}
+
+int sceNgs2SystemCreateWithAllocator(const Ngs2SystemOption* option, const Ngs2BufferAllocator* allocator, uintptr_t* handle) {
+ (void)option;
+ (void)allocator;
+ (void)handle;
+ return 0;
+}
+
+int sceNgs2SystemDestroy(uintptr_t system_handle, Ngs2ContextBufferInfo* buffer_info) {
+ (void)system_handle;
+ (void)buffer_info;
+ return 0;
+}
+
+int sceNgs2SystemGetInfo(uintptr_t system_handle, Ngs2SystemInfo* info, size_t info_size) {
+ (void)system_handle;
+ (void)info;
+ (void)info_size;
+ return 0;
+}
+
+int sceNgs2SystemQueryBufferSize(const Ngs2SystemOption* option, Ngs2ContextBufferInfo* buffer_info) {
+ (void)option;
+ (void)buffer_info;
+ return 0;
+}
+
+int sceNgs2SystemRender(uintptr_t system_handle, const Ngs2RenderBufferInfo* buffer_info, uint32_t num_buffer_info) {
+ (void)system_handle;
+ (void)buffer_info;
+ (void)num_buffer_info;
+ return 0;
+}
+
+int sceNgs2SystemResetOption(Ngs2SystemOption* option) {
+ (void)option;
+ return 0;
+}
+
+int sceNgs2SystemSetGrainSamples(uintptr_t system_handle, uint32_t num_samples) {
+ (void)system_handle;
+ (void)num_samples;
+ return 0;
+}
+
+int sceNgs2VoiceControl(uintptr_t voice_handle, const Ngs2VoiceParamHeader* param_list) {
+ (void)voice_handle;
+ (void)param_list;
+ return 0;
+}
+
+int sceNgs2VoiceGetState(uintptr_t voice_handle, Ngs2VoiceState* state, size_t state_size) {
+ (void)voice_handle;
+ (void)state;
+ (void)state_size;
+ return 0;
+}
+
+int sceNgs2VoiceGetStateFlags(uintptr_t voice_handle, uint32_t* state_flags) {
+ (void)voice_handle;
+ (void)state_flags;
+ return 0;
+}
+
+int sceNgs2VoiceRunCommands(uintptr_t voice_handle, const void* commands, uint32_t num_commands, uint32_t flags) {
+ (void)voice_handle;
+ (void)commands;
+ (void)num_commands;
+ (void)flags;
+ return 0;
+}
+
+}

core/libs/prx/libSceNgs2/Export.cpp

@@ -0,0 +1,177 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceNgs2CalcWaveformBlock(const Ngs2WaveformFormat* format, uint32_t sample_pos, uint32_t num_samples, Ngs2WaveformBlock* block) {
+ (void)format;
+ (void)sample_pos;
+ (void)num_samples;
+ (void)block;
+ return 0;
+}
+
+int sceNgs2GeomApply(const Ngs2GeomListenerWork* listener, const Ngs2GeomSourceParam* source, Ngs2GeomAttribute* out_attrib, uint32_t flags) {
+ (void)listener;
+ (void)source;
+ (void)out_attrib;
+ (void)flags;
+ return 0;
+}
+
+int sceNgs2GeomCalcListener(const Ngs2GeomListenerParam* param, Ngs2GeomListenerWork* out_work, uint32_t flags) {
+ (void)param;
+ (void)out_work;
+ (void)flags;
+ return 0;
+}
+
+int sceNgs2GeomResetListenerParam(Ngs2GeomListenerParam* out_listener_param) {
+ (void)out_listener_param;
+ return 0;
+}
+
+int sceNgs2GeomResetSourceParam(Ngs2GeomSourceParam* out_source_param) {
+ (void)out_source_param;
+ return 0;
+}
+
+int sceNgs2PanGetVolumeMatrix(Ngs2PanWork* work, const Ngs2PanParam* params, uint32_t num_params, uint32_t matrix_format, float* out_volume_matrix) {
+ (void)work;
+ (void)params;
+ (void)num_params;
+ (void)matrix_format;
+ (void)out_volume_matrix;
+ return 0;
+}
+
+int sceNgs2PanInit(Ngs2PanWork* work, const float* speaker_angles, float unit_angle, uint32_t num_speakers) {
+ (void)work;
+ (void)speaker_angles;
+ (void)unit_angle;
+ (void)num_speakers;
+ return 0;
+}
+
+int sceNgs2ParseWaveformData(const void* data, size_t data_size, Ngs2WaveformInfo* info) {
+ (void)data;
+ (void)data_size;
+ (void)info;
+ return 0;
+}
+
+int sceNgs2RackCreate(uintptr_t system_handle, uint32_t rack_id, const Ngs2RackOption* option, const Ngs2ContextBufferInfo* buffer_info, uintptr_t* handle) {
+ (void)system_handle;
+ (void)rack_id;
+ (void)option;
+ (void)buffer_info;
+ (void)handle;
+ return 0;
+}
+
+int sceNgs2RackCreateWithAllocator(uintptr_t system_handle, uint32_t rack_id, const Ngs2RackOption* option, const Ngs2BufferAllocator* allocator, uintptr_t* handle) {
+ (void)system_handle;
+ (void)rack_id;
+ (void)option;
+ (void)allocator;
+ (void)handle;
+ return 0;
+}
+
+int sceNgs2RackDestroy(uintptr_t rack_handle, Ngs2ContextBufferInfo* buffer_info) {
+ (void)rack_handle;
+ (void)buffer_info;
+ return 0;
+}
+
+int sceNgs2RackGetVoiceHandle(uintptr_t rack_handle, uint32_t voice_id, uintptr_t* handle) {
+ (void)rack_handle;
+ (void)voice_id;
+ (void)handle;
+ return 0;
+}
+
+int sceNgs2RackLock(uintptr_t rack_handle) {
+ (void)rack_handle;
+ return 0;
+}
+
+int sceNgs2RackQueryBufferSize(uint32_t rack_id, const Ngs2RackOption* option, Ngs2ContextBufferInfo* buffer_info) {
+ (void)rack_id;
+ (void)option;
+ (void)buffer_info;
+ return 0;
+}
+
+int sceNgs2RackUnlock(uintptr_t rack_handle) {
+ (void)rack_handle;
+ return 0;
+}
+
+int sceNgs2SystemCreate(const Ngs2SystemOption* option, const Ngs2ContextBufferInfo* buffer_info, uintptr_t* handle) {
+ (void)option;
+ (void)buffer_info;
+ (void)handle;
+ return 0;
+}
+
+int sceNgs2SystemCreateWithAllocator(const Ngs2SystemOption* option, const Ngs2BufferAllocator* allocator, uintptr_t* handle) {
+ (void)option;
+ (void)allocator;
+ (void)handle;
+ return 0;
+}
+
+int sceNgs2SystemDestroy(uintptr_t system_handle, Ngs2ContextBufferInfo* buffer_info) {
+ (void)system_handle;
+ (void)buffer_info;
+ return 0;
+}
+
+int sceNgs2SystemGetInfo(uintptr_t system_handle, Ngs2SystemInfo* info, size_t info_size) {
+ (void)system_handle;
+ (void)info;
+ (void)info_size;
+ return 0;
+}
+
+int sceNgs2SystemQueryBufferSize(const Ngs2SystemOption* option, Ngs2ContextBufferInfo* buffer_info) {
+ (void)option;
+ (void)buffer_info;
+ return 0;
+}
+
+int sceNgs2SystemRender(uintptr_t system_handle, const Ngs2RenderBufferInfo* buffer_info, uint32_t num_buffer_info) {
+ (void)system_handle;
+ (void)buffer_info;
+ (void)num_buffer_info;
+ return 0;
+}
+
+int sceNgs2SystemSetGrainSamples(uintptr_t system_handle, uint32_t num_samples) {
+ (void)system_handle;
+ (void)num_samples;
+ return 0;
+}
+
+int sceNgs2VoiceControl(uintptr_t voice_handle, const Ngs2VoiceParamHeader* param_list) {
+ (void)voice_handle;
+ (void)param_list;
+ return 0;
+}
+
+int sceNgs2VoiceGetState(uintptr_t voice_handle, Ngs2VoiceState* state, size_t state_size) {
+ (void)voice_handle;
+ (void)state;
+ (void)state_size;
+ return 0;
+}
+
+int sceNgs2VoiceGetStateFlags(uintptr_t voice_handle, uint32_t* state_flags) {
+ (void)voice_handle;
+ (void)state_flags;
+ return 0;
+}
+
+}

core/libs/prx/libSceNpAuth/Export.cpp

@@ -0,0 +1,53 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceNpAuthAbortRequest(int req_id) {
+ (void)req_id;
+ return 0;
+}
+
+int sceNpAuthCreateAsyncRequest(const void* param) {
+ (void)param;
+ return 0;
+}
+
+int sceNpAuthCreateRequest(void) {
+ return 0;
+}
+
+int sceNpAuthDeleteRequest(int req_id) {
+ (void)req_id;
+ return 0;
+}
+
+int sceNpAuthGetAuthorizationCodeV3(int req_id, const void* param, void* auth_code, int* issuer_id) {
+ (void)req_id;
+ (void)param;
+ (void)auth_code;
+ (void)issuer_id;
+ return 0;
+}
+
+int sceNpAuthGetIdTokenV3(int req_id, const void* param, void* id_token) {
+ (void)req_id;
+ (void)param;
+ (void)id_token;
+ return 0;
+}
+
+int sceNpAuthPollAsync(int req_id, int* result) {
+ (void)req_id;
+ (void)result;
+ return 0;
+}
+
+int sceNpAuthWaitAsync(int req_id, int* result) {
+ (void)req_id;
+ (void)result;
+ return 0;
+}
+
+}

core/libs/prx/libSceNpCommerce/Export.cpp

@@ -0,0 +1,11 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceNpCommerceDialogUpdateStatus(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceNpEntitlementAccess/Export.cpp

@@ -0,0 +1,33 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceNpEntitlementAccessGetAddcontEntitlementInfo(uint32_t service_label, const NpUnifiedEntitlementLabel* entitlement_label, NpEntitlementAccessAddcontEntitlementInfo* info) {
+ (void)service_label;
+ (void)entitlement_label;
+ (void)info;
+ return 0;
+}
+
+int sceNpEntitlementAccessGetAddcontEntitlementInfoList(uint32_t service_label, NpEntitlementAccessAddcontEntitlementInfo* list, uint32_t list_num, uint32_t* hit_num) {
+ (void)service_label;
+ (void)list;
+ (void)list_num;
+ (void)hit_num;
+ return 0;
+}
+
+int sceNpEntitlementAccessGetSkuFlag(uint32_t* sku_flag) {
+ (void)sku_flag;
+ return 0;
+}
+
+int sceNpEntitlementAccessInitialize(const NpEntitlementAccessInitParam* init_param, NpEntitlementAccessBootParam* boot_param) {
+ (void)init_param;
+ (void)boot_param;
+ return 0;
+}
+
+}

core/libs/prx/libSceNpGameIntent/Export.cpp

@@ -0,0 +1,29 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceNpGameIntentGetPropertyValueString(const NpGameIntentData* intent_data, const char* key, char* value_buf, size_t buf_size) {
+ (void)intent_data;
+ (void)key;
+ (void)value_buf;
+ (void)buf_size;
+ return 0;
+}
+
+int sceNpGameIntentInitialize(const void* init_param) {
+ (void)init_param;
+ return 0;
+}
+
+int sceNpGameIntentReceiveIntent(NpGameIntentInfo* intent_info) {
+ (void)intent_info;
+ return 0;
+}
+
+int sceNpGameIntentTerminate(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceNpManager/Export.cpp

@@ -0,0 +1,149 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceNpAbortRequest(int req_id) {
+ (void)req_id;
+ return 0;
+}
+
+int sceNpCheckCallback(void) {
+ return 0;
+}
+
+int sceNpCheckNpAvailability(int req_id, const char* user, void* result) {
+ (void)req_id;
+ (void)user;
+ (void)result;
+ return 0;
+}
+
+int sceNpCheckNpReachability(int req_id, int user_id) {
+ (void)req_id;
+ (void)user_id;
+ return 0;
+}
+
+int sceNpCheckPremium(int req_id, const NpCheckPremiumParameter* param, NpCheckPremiumResult* result) {
+ (void)req_id;
+ (void)param;
+ (void)result;
+ return 0;
+}
+
+int sceNpCreateAsyncRequest(const NpCreateAsyncRequestParameter* param) {
+ (void)param;
+ return 0;
+}
+
+int sceNpCreateRequest(void) {
+ return 0;
+}
+
+int sceNpDeleteRequest(int req_id) {
+ (void)req_id;
+ return 0;
+}
+
+int sceNpGetAccountAge(int req_id, int user_id, uint8_t* age) {
+ (void)req_id;
+ (void)user_id;
+ (void)age;
+ return 0;
+}
+
+int sceNpGetAccountCountryA(int user_id, void* country_code) {
+ (void)user_id;
+ (void)country_code;
+ return 0;
+}
+
+int sceNpGetAccountIdA(int user_id, uint64_t* account_id) {
+ (void)user_id;
+ (void)account_id;
+ return 0;
+}
+
+int sceNpGetNpId(int user_id, NpId* np_id) {
+ (void)user_id;
+ (void)np_id;
+ return 0;
+}
+
+int sceNpGetNpReachabilityState(int user_id, uint32_t* state) {
+ (void)user_id;
+ (void)state;
+ return 0;
+}
+
+int sceNpGetOnlineId(int user_id, NpOnlineId* online_id) {
+ (void)user_id;
+ (void)online_id;
+ return 0;
+}
+
+int sceNpGetState(int user_id, uint32_t* state) {
+ (void)user_id;
+ (void)state;
+ return 0;
+}
+
+int sceNpHasSignedUp(int user_id, bool* has_signed_up) {
+ (void)user_id;
+ (void)has_signed_up;
+ return 0;
+}
+
+int sceNpPollAsync(int req_id, int* result) {
+ (void)req_id;
+ (void)result;
+ return 0;
+}
+
+void sceNpRegisterGamePresenceCallback(void* callback, void* userdata) {
+ (void)callback;
+ (void)userdata;
+}
+
+int sceNpRegisterNpReachabilityStateCallback(void* callback, void* userdata) {
+ (void)callback;
+ (void)userdata;
+ return 0;
+}
+
+int sceNpRegisterPlusEventCallback(void* callback, void* userdata) {
+ (void)callback;
+ (void)userdata;
+ return 0;
+}
+
+int sceNpRegisterPremiumEventCallback(void* callback, void* userdata) {
+ (void)callback;
+ (void)userdata;
+ return 0;
+}
+
+int sceNpRegisterStateCallback(void* callback, void* userdata) {
+ (void)callback;
+ (void)userdata;
+ return 0;
+}
+
+int sceNpSetContentRestriction(const NpContentRestriction* restriction) {
+ (void)restriction;
+ return 0;
+}
+
+int sceNpSetNpTitleId(const NpTitleId* title_id, const NpTitleSecret* title_secret) {
+ (void)title_id;
+ (void)title_secret;
+ return 0;
+}
+
+int sceNpUnregisterStateCallback(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceNpSessionSignaling/Export.cpp

@@ -0,0 +1,12 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceNpSessionSignalingInitialize(void* param) {
+ (void)param;
+ return 0;
+}
+
+}

core/libs/prx/libSceNpTrophy2/Export.cpp

@@ -0,0 +1,122 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceNpTrophy2AbortHandle(int handle) {
+ (void)handle;
+ return 0;
+}
+
+int sceNpTrophy2CreateContext(int* context, int user_id, uint32_t service_label, uint64_t options) {
+ (void)context;
+ (void)user_id;
+ (void)service_label;
+ (void)options;
+ return 0;
+}
+
+int sceNpTrophy2CreateHandle(int* handle) {
+ (void)handle;
+ return 0;
+}
+
+int sceNpTrophy2DestroyContext(int context) {
+ (void)context;
+ return 0;
+}
+
+int sceNpTrophy2DestroyHandle(int handle) {
+ (void)handle;
+ return 0;
+}
+
+int sceNpTrophy2GetGameIcon(int context, int handle, void* buffer, size_t* size) {
+ (void)context;
+ (void)handle;
+ (void)buffer;
+ (void)size;
+ return 0;
+}
+
+int sceNpTrophy2GetGameInfo(int context, int handle, NpTrophy2GameDetails* details, NpTrophy2GameData* data) {
+ (void)context;
+ (void)handle;
+ (void)details;
+ (void)data;
+ return 0;
+}
+
+int sceNpTrophy2GetGroupIcon(int context, int handle, int group_id, void* buffer, size_t* size) {
+ (void)context;
+ (void)handle;
+ (void)group_id;
+ (void)buffer;
+ (void)size;
+ return 0;
+}
+
+int sceNpTrophy2GetGroupInfo(int context, int handle, int group_id, NpTrophy2GroupDetails* details, NpTrophy2GroupData* data) {
+ (void)context;
+ (void)handle;
+ (void)group_id;
+ (void)details;
+ (void)data;
+ return 0;
+}
+
+int sceNpTrophy2GetGroupInfoArray(int context, int handle, uint32_t offset, uint32_t limit, NpTrophy2GroupDetails* details_array, NpTrophy2GroupData* data_array, uint32_t* count) {
+ (void)context;
+ (void)handle;
+ (void)offset;
+ (void)limit;
+ (void)details_array;
+ (void)data_array;
+ (void)count;
+ return 0;
+}
+
+int sceNpTrophy2GetTrophyIcon(int context, int handle, int trophy_id, void* buffer, size_t* size) {
+ (void)context;
+ (void)handle;
+ (void)trophy_id;
+ (void)buffer;
+ (void)size;
+ return 0;
+}
+
+int sceNpTrophy2GetTrophyInfo(int context, int handle, int trophy_id, NpTrophy2Details* details, NpTrophy2Data* data) {
+ (void)context;
+ (void)handle;
+ (void)trophy_id;
+ (void)details;
+ (void)data;
+ return 0;
+}
+
+int sceNpTrophy2GetTrophyInfoArray(int context, int handle, uint32_t offset, uint32_t limit, NpTrophy2Details* details_array, NpTrophy2Data* data_array, uint32_t* count) {
+ (void)context;
+ (void)handle;
+ (void)offset;
+ (void)limit;
+ (void)details_array;
+ (void)data_array;
+ (void)count;
+ return 0;
+}
+
+int sceNpTrophy2RegisterContext(int context, int handle, uint64_t options) {
+ (void)context;
+ (void)handle;
+ (void)options;
+ return 0;
+}
+
+int sceNpTrophy2RegisterUnlockCallback(void* callback, void* userdata) {
+ (void)callback;
+ (void)userdata;
+ return 0;
+}
+
+}

core/libs/prx/libSceNpUniversalDataSystem/Export.cpp

@@ -0,0 +1,266 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceNpUniversalDataSystemAbortHandle(int handle) {
+ (void)handle;
+ return 0;
+}
+
+int sceNpUniversalDataSystemCreateContext(int* context, int user_id, uint32_t service_label, uint64_t options) {
+ (void)context;
+ (void)user_id;
+ (void)service_label;
+ (void)options;
+ return 0;
+}
+
+int sceNpUniversalDataSystemCreateEvent(const char* event_name, const NpUniversalDataSystemEventPropertyObject* prop, NpUniversalDataSystemEvent** new_event, NpUniversalDataSystemEventPropertyObject** prop_ptr) {
+ (void)event_name;
+ (void)prop;
+ (void)new_event;
+ (void)prop_ptr;
+ return 0;
+}
+
+int sceNpUniversalDataSystemCreateEventPropertyArray(NpUniversalDataSystemEventPropertyArray** new_array) {
+ (void)new_array;
+ return 0;
+}
+
+int sceNpUniversalDataSystemCreateEventPropertyObject(NpUniversalDataSystemEventPropertyObject** new_object) {
+ (void)new_object;
+ return 0;
+}
+
+int sceNpUniversalDataSystemCreateHandle(int* handle) {
+ (void)handle;
+ return 0;
+}
+
+int sceNpUniversalDataSystemDestroyContext(int context) {
+ (void)context;
+ return 0;
+}
+
+int sceNpUniversalDataSystemDestroyEvent(NpUniversalDataSystemEvent* event) {
+ (void)event;
+ return 0;
+}
+
+int sceNpUniversalDataSystemDestroyEventPropertyArray(NpUniversalDataSystemEventPropertyArray* array) {
+ (void)array;
+ return 0;
+}
+
+int sceNpUniversalDataSystemDestroyEventPropertyObject(NpUniversalDataSystemEventPropertyObject* object) {
+ (void)object;
+ return 0;
+}
+
+int sceNpUniversalDataSystemDestroyHandle(int handle) {
+ (void)handle;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventEstimateSize(const NpUniversalDataSystemEvent* event, size_t* size) {
+ (void)event;
+ (void)size;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyArraySetArray(NpUniversalDataSystemEventPropertyArray* array, const NpUniversalDataSystemEventPropertyArray* value, NpUniversalDataSystemEventPropertyArray** value_ptr) {
+ (void)array;
+ (void)value;
+ (void)value_ptr;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyArraySetBinary(NpUniversalDataSystemEventPropertyArray* array, const void* value, size_t value_size) {
+ (void)array;
+ (void)value;
+ (void)value_size;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyArraySetBool(NpUniversalDataSystemEventPropertyArray* array, bool value) {
+ (void)array;
+ (void)value;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyArraySetFloat32(NpUniversalDataSystemEventPropertyArray* array, float value) {
+ (void)array;
+ (void)value;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyArraySetFloat64(NpUniversalDataSystemEventPropertyArray* array, double value) {
+ (void)array;
+ (void)value;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyArraySetInt32(NpUniversalDataSystemEventPropertyArray* array, int32_t value) {
+ (void)array;
+ (void)value;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyArraySetInt64(NpUniversalDataSystemEventPropertyArray* array, int64_t value) {
+ (void)array;
+ (void)value;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyArraySetObject(NpUniversalDataSystemEventPropertyArray* array, const NpUniversalDataSystemEventPropertyObject* value, NpUniversalDataSystemEventPropertyObject** value_ptr) {
+ (void)array;
+ (void)value;
+ (void)value_ptr;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyArraySetString(NpUniversalDataSystemEventPropertyArray* array, const char* value) {
+ (void)array;
+ (void)value;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyArraySetUInt32(NpUniversalDataSystemEventPropertyArray* array, uint32_t value) {
+ (void)array;
+ (void)value;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyArraySetUInt64(NpUniversalDataSystemEventPropertyArray* array, uint64_t value) {
+ (void)array;
+ (void)value;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyObjectSetArray(NpUniversalDataSystemEventPropertyObject* object, const char* key, const NpUniversalDataSystemEventPropertyArray* value, NpUniversalDataSystemEventPropertyArray** value_ptr) {
+ (void)object;
+ (void)key;
+ (void)value;
+ (void)value_ptr;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyObjectSetBinary(NpUniversalDataSystemEventPropertyObject* object, const char* key, const void* value, size_t value_size) {
+ (void)object;
+ (void)key;
+ (void)value;
+ (void)value_size;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyObjectSetBool(NpUniversalDataSystemEventPropertyObject* object, const char* key, bool value) {
+ (void)object;
+ (void)key;
+ (void)value;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyObjectSetFloat32(NpUniversalDataSystemEventPropertyObject* object, const char* key, float value) {
+ (void)object;
+ (void)key;
+ (void)value;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyObjectSetFloat64(NpUniversalDataSystemEventPropertyObject* object, const char* key, double value) {
+ (void)object;
+ (void)key;
+ (void)value;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyObjectSetInt32(NpUniversalDataSystemEventPropertyObject* object, const char* key, int32_t value) {
+ (void)object;
+ (void)key;
+ (void)value;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyObjectSetInt64(NpUniversalDataSystemEventPropertyObject* object, const char* key, int64_t value) {
+ (void)object;
+ (void)key;
+ (void)value;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyObjectSetObject(NpUniversalDataSystemEventPropertyObject* object, const char* key, const NpUniversalDataSystemEventPropertyObject* value, NpUniversalDataSystemEventPropertyObject** value_ptr) {
+ (void)object;
+ (void)key;
+ (void)value;
+ (void)value_ptr;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyObjectSetString(NpUniversalDataSystemEventPropertyObject* object, const char* key, const char* value) {
+ (void)object;
+ (void)key;
+ (void)value;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyObjectSetUInt32(NpUniversalDataSystemEventPropertyObject* object, const char* key, uint32_t value) {
+ (void)object;
+ (void)key;
+ (void)value;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventPropertyObjectSetUInt64(NpUniversalDataSystemEventPropertyObject* object, const char* key, uint64_t value) {
+ (void)object;
+ (void)key;
+ (void)value;
+ return 0;
+}
+
+int sceNpUniversalDataSystemEventToString(const NpUniversalDataSystemEvent* event, char* buf, size_t buf_size, size_t* string_size) {
+ (void)event;
+ (void)buf;
+ (void)buf_size;
+ (void)string_size;
+ return 0;
+}
+
+int sceNpUniversalDataSystemGetMemoryStat(NpUniversalDataSystemMemoryStat* stat) {
+ (void)stat;
+ return 0;
+}
+
+int sceNpUniversalDataSystemGetStorageStat(int context, NpUniversalDataSystemStorageStat* stat) {
+ (void)context;
+ (void)stat;
+ return 0;
+}
+
+int sceNpUniversalDataSystemInitialize(const NpUniversalDataSystemInitParam* param) {
+ (void)param;
+ return 0;
+}
+
+int sceNpUniversalDataSystemPostEvent(int context, int handle, const void* event, uint64_t options) {
+ (void)context;
+ (void)handle;
+ (void)event;
+ (void)options;
+ return 0;
+}
+
+int sceNpUniversalDataSystemRegisterContext(int context, int handle, uint64_t options) {
+ (void)context;
+ (void)handle;
+ (void)options;
+ return 0;
+}
+
+int sceNpUniversalDataSystemTerminate(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceNpWebApi2/Export.cpp

@@ -0,0 +1,124 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceNpWebApi2AbortRequest(int64_t request_id) {
+ (void)request_id;
+ return 0;
+}
+
+int sceNpWebApi2AddHttpRequestHeader(int64_t request_id, const char* field_name, const char* value) {
+ (void)request_id;
+ (void)field_name;
+ (void)value;
+ return 0;
+}
+
+void sceNpWebApi2CheckTimeout(void) {
+}
+
+int sceNpWebApi2CreateRequest(int user_context_id, const char* api_group, const char* path, const char* method, const void* content_parameter, int64_t* request_id) {
+ (void)user_context_id;
+ (void)api_group;
+ (void)path;
+ (void)method;
+ (void)content_parameter;
+ (void)request_id;
+ return 0;
+}
+
+int sceNpWebApi2CreateUserContext(int lib_ctx_id, int user_id) {
+ (void)lib_ctx_id;
+ (void)user_id;
+ return 0;
+}
+
+int sceNpWebApi2DeleteRequest(int64_t request_id) {
+ (void)request_id;
+ return 0;
+}
+
+int sceNpWebApi2DeleteUserContext(int user_context_id) {
+ (void)user_context_id;
+ return 0;
+}
+
+int sceNpWebApi2GetHttpResponseHeaderValue(int64_t request_id, const char* field_name, char* value, size_t value_size) {
+ (void)request_id;
+ (void)field_name;
+ (void)value;
+ (void)value_size;
+ return 0;
+}
+
+int sceNpWebApi2GetHttpResponseHeaderValueLength(int64_t request_id, const char* field_name, size_t* value_length) {
+ (void)request_id;
+ (void)field_name;
+ (void)value_length;
+ return 0;
+}
+
+int sceNpWebApi2Initialize(int lib_http_ctx_id, size_t pool_size) {
+ (void)lib_http_ctx_id;
+ (void)pool_size;
+ return 0;
+}
+
+int sceNpWebApi2PushEventCreateFilter(int lib_ctx_id, int handle_id, const char* np_service_name, uint32_t np_service_label, const void* filter_param, size_t filter_param_num) {
+ (void)lib_ctx_id;
+ (void)handle_id;
+ (void)np_service_name;
+ (void)np_service_label;
+ (void)filter_param;
+ (void)filter_param_num;
+ return 0;
+}
+
+int sceNpWebApi2PushEventCreateHandle(int lib_ctx_id) {
+ (void)lib_ctx_id;
+ return 0;
+}
+
+int sceNpWebApi2PushEventDeleteHandle(int lib_ctx_id, int handle_id) {
+ (void)lib_ctx_id;
+ (void)handle_id;
+ return 0;
+}
+
+int sceNpWebApi2PushEventDeletePushContext(int user_context_id, const void* push_context_id) {
+ (void)user_context_id;
+ (void)push_context_id;
+ return 0;
+}
+
+int sceNpWebApi2PushEventRegisterCallback(int user_context_id, int filter_id, void* callback, void* user_arg) {
+ (void)user_context_id;
+ (void)filter_id;
+ (void)callback;
+ (void)user_arg;
+ return 0;
+}
+
+int sceNpWebApi2ReadData(int64_t request_id, void* data, size_t size) {
+ (void)request_id;
+ (void)data;
+ (void)size;
+ return 0;
+}
+
+int sceNpWebApi2SendRequest(int64_t request_id, const void* data, size_t data_size, NpWebApi2ResponseInformationOption* response_info_option) {
+ (void)request_id;
+ (void)data;
+ (void)data_size;
+ (void)response_info_option;
+ return 0;
+}
+
+int sceNpWebApi2Terminate(int lib_ctx_id) {
+ (void)lib_ctx_id;
+ return 0;
+}
+
+}

core/libs/prx/libScePad/Export.cpp

@@ -0,0 +1,126 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int scePadClose(int handle) {
+ (void)handle;
+ return 0;
+}
+
+int scePadDeviceClassGetExtendedInformation(int handle, PadDeviceClassExtendedInformation* info) {
+ (void)handle;
+ (void)info;
+ return 0;
+}
+
+int scePadDeviceClassParseData(int handle, const PadData* data, PadDeviceClassData* class_data) {
+ (void)handle;
+ (void)data;
+ (void)class_data;
+ return 0;
+}
+
+int scePadGetControllerInformation(int handle, PadControllerInformation* info) {
+ (void)handle;
+ (void)info;
+ return 0;
+}
+
+int scePadGetHandle(int user_id, int type, int index) {
+ (void)user_id;
+ (void)type;
+ (void)index;
+ return 0;
+}
+
+int scePadGetTriggerEffectState(int handle, PadTriggerEffectStateInformation* info) {
+ (void)handle;
+ (void)info;
+ return 0;
+}
+
+int scePadInit(void) {
+ return 0;
+}
+
+int scePadOpen(int user_id, int type, int index, const void* param) {
+ (void)user_id;
+ (void)type;
+ (void)index;
+ (void)param;
+ return 0;
+}
+
+int scePadRead(int handle, PadData* data, int num) {
+ (void)handle;
+ (void)data;
+ (void)num;
+ return 0;
+}
+
+int scePadReadState(int handle, PadData* data) {
+ (void)handle;
+ (void)data;
+ return 0;
+}
+
+int scePadResetLightBar(int handle) {
+ (void)handle;
+ return 0;
+}
+
+int scePadResetOrientation(int handle) {
+ (void)handle;
+ return 0;
+}
+
+int scePadSetAngularVelocityDeadbandState(int handle, bool enable) {
+ (void)handle;
+ (void)enable;
+ return 0;
+}
+
+int scePadSetLightBar(int handle, const PadLightBarParam* param) {
+ (void)handle;
+ (void)param;
+ return 0;
+}
+
+int scePadSetMotionSensorState(int handle, bool enable) {
+ (void)handle;
+ (void)enable;
+ return 0;
+}
+
+int scePadSetTiltCorrectionState(int handle, bool enabled) {
+ (void)handle;
+ (void)enabled;
+ return 0;
+}
+
+int scePadSetTriggerEffect(int handle, const void* param) {
+ (void)handle;
+ (void)param;
+ return 0;
+}
+
+int scePadSetVibration(int handle, const PadVibrationParam* param) {
+ (void)handle;
+ (void)param;
+ return 0;
+}
+
+int scePadSetVibrationMode(int handle, int mode) {
+ (void)handle;
+ (void)mode;
+ return 0;
+}
+
+int scePadSetVibrationTriggerEffectWeakWhileEmbeddedMicInUse(bool enabled) {
+ (void)enabled;
+ return 0;
+}
+
+}

core/libs/prx/libScePlayGo/Export.cpp

@@ -0,0 +1,129 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int scePlayGoClose(int handle) {
+ (void)handle;
+ return 0;
+}
+
+int scePlayGoGetChunkId(int handle, uint16_t* out_chunk_id_list, uint32_t number_of_entries, uint32_t* out_entries) {
+ (void)handle;
+ (void)out_chunk_id_list;
+ (void)number_of_entries;
+ (void)out_entries;
+ return 0;
+}
+
+int scePlayGoGetEta(int handle, const uint16_t* chunk_ids, uint32_t number_of_entries, int64_t* out_eta) {
+ (void)handle;
+ (void)chunk_ids;
+ (void)number_of_entries;
+ (void)out_eta;
+ return 0;
+}
+
+int scePlayGoGetInstallChunkId(int handle, uint16_t* out_chunk_id_list, uint32_t number_of_entries, uint32_t* out_entries) {
+ (void)handle;
+ (void)out_chunk_id_list;
+ (void)number_of_entries;
+ (void)out_entries;
+ return 0;
+}
+
+int scePlayGoGetInstallSpeed(int handle, int32_t* out_speed) {
+ (void)handle;
+ (void)out_speed;
+ return 0;
+}
+
+int scePlayGoGetLanguageMask(int handle, uint64_t* out_language_mask) {
+ (void)handle;
+ (void)out_language_mask;
+ return 0;
+}
+
+int scePlayGoGetLocus(int handle, const uint16_t* chunk_ids, uint32_t number_of_entries, int8_t* out_loci) {
+ (void)handle;
+ (void)chunk_ids;
+ (void)number_of_entries;
+ (void)out_loci;
+ return 0;
+}
+
+int scePlayGoGetOptionalChunk(int handle, int32_t type, PlayGoOptionalChunk* option) {
+ (void)handle;
+ (void)type;
+ (void)option;
+ return 0;
+}
+
+int scePlayGoGetProgress(int handle, const uint16_t* chunk_ids, uint32_t number_of_entries, PlayGoProgress* out_progress) {
+ (void)handle;
+ (void)chunk_ids;
+ (void)number_of_entries;
+ (void)out_progress;
+ return 0;
+}
+
+int scePlayGoGetSupportedOptionalChunk(int handle, int32_t type, PlayGoOptionalChunk* option) {
+ (void)handle;
+ (void)type;
+ (void)option;
+ return 0;
+}
+
+int scePlayGoGetToDoList(int handle, PlayGoToDo* out_todo_list, uint32_t number_of_entries, uint32_t* out_entries) {
+ (void)handle;
+ (void)out_todo_list;
+ (void)number_of_entries;
+ (void)out_entries;
+ return 0;
+}
+
+int scePlayGoInitialize(const PlayGoInitParams* init) {
+ (void)init;
+ return 0;
+}
+
+int scePlayGoOpen(int* out_handle, const void* param) {
+ (void)out_handle;
+ (void)param;
+ return 0;
+}
+
+int scePlayGoPrefetch(int handle, const uint16_t* chunk_ids, uint32_t number_of_entries, int8_t minimum_locus) {
+ (void)handle;
+ (void)chunk_ids;
+ (void)number_of_entries;
+ (void)minimum_locus;
+ return 0;
+}
+
+int scePlayGoPrefetchOptionalChunk(int handle, int32_t type, const PlayGoOptionalChunk* option) {
+ (void)handle;
+ (void)type;
+ (void)option;
+ return 0;
+}
+
+int scePlayGoSetInstallSpeed(int handle, int32_t speed) {
+ (void)handle;
+ (void)speed;
+ return 0;
+}
+
+int scePlayGoSetToDoList(int handle, const PlayGoToDo* todo_list, uint32_t number_of_entries) {
+ (void)handle;
+ (void)todo_list;
+ (void)number_of_entries;
+ return 0;
+}
+
+int scePlayGoTerminate(void) {
+ return 0;
+}
+
+}

core/libs/prx/libScePngDec/Export.cpp

@@ -0,0 +1,38 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int32_t scePngDecCreate(const PngDecCreateParam* param, void* memory_address, uint32_t memory_size, void** handle) {
+ (void)param;
+ (void)memory_address;
+ (void)memory_size;
+ (void)handle;
+ return 0;
+}
+
+int32_t scePngDecDecode(void* handle, const PngDecDecodeParam* param, PngDecImageInfo* image_info) {
+ (void)handle;
+ (void)param;
+ (void)image_info;
+ return 0;
+}
+
+int32_t scePngDecDelete(void* handle) {
+ (void)handle;
+ return 0;
+}
+
+int32_t scePngDecParseHeader(const PngDecParseParam* param, PngDecImageInfo* image_info) {
+ (void)param;
+ (void)image_info;
+ return 0;
+}
+
+int32_t scePngDecQueryMemorySize(const PngDecCreateParam* param) {
+ (void)param;
+ return 0;
+}
+
+}

core/libs/prx/libSceRandom/Export.cpp

@@ -0,0 +1,13 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceRandomGetRandomNumber(void* buf, size_t size) {
+ (void)buf;
+ (void)size;
+ return 0;
+}
+
+}

core/libs/prx/libSceRazorCpu/Export.cpp

@@ -0,0 +1,11 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+uint32_t sceRazorCpuIsCapturing(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceRemoteplay/Export.cpp

@@ -0,0 +1,23 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceRemoteplayGetConnectionStatus(int user_id, int* status) {
+ (void)user_id;
+ (void)status;
+ return 0;
+}
+
+int sceRemoteplayInitialize(void* heap, size_t heap_size) {
+ (void)heap;
+ (void)heap_size;
+ return 0;
+}
+
+int sceRemoteplayTerminate(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceRtc/Export.cpp

@@ -0,0 +1,159 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceRtcCheckValid(const RtcDateTime* time) {
+ (void)time;
+ return 0;
+}
+
+int sceRtcConvertLocalTimeToUtc(const RtcTick* local_time, RtcTick* utc) {
+ (void)local_time;
+ (void)utc;
+ return 0;
+}
+
+int sceRtcConvertUtcToLocalTime(const RtcTick* utc, RtcTick* local_time) {
+ (void)utc;
+ (void)local_time;
+ return 0;
+}
+
+int sceRtcFormatRFC3339(char* date_time, const RtcTick* utc, int time_zone_minutes) {
+ (void)date_time;
+ (void)utc;
+ (void)time_zone_minutes;
+ return 0;
+}
+
+int sceRtcGetCurrentClock(RtcDateTime* time, int time_zone_minutes) {
+ (void)time;
+ (void)time_zone_minutes;
+ return 0;
+}
+
+int sceRtcGetCurrentClockLocalTime(RtcDateTime* time) {
+ (void)time;
+ return 0;
+}
+
+int sceRtcGetCurrentNetworkTick(RtcTick* tick) {
+ (void)tick;
+ return 0;
+}
+
+int sceRtcGetCurrentTick(RtcTick* tick) {
+ (void)tick;
+ return 0;
+}
+
+int sceRtcGetDayOfWeek(int year, int month, int day) {
+ (void)year;
+ (void)month;
+ (void)day;
+ return 0;
+}
+
+int sceRtcGetTick(const RtcDateTime* time, RtcTick* tick) {
+ (void)time;
+ (void)tick;
+ return 0;
+}
+
+int sceRtcGetTickResolution(void) {
+ return 0;
+}
+
+int sceRtcGetTime_t(const RtcDateTime* time, int64_t* seconds) {
+ (void)time;
+ (void)seconds;
+ return 0;
+}
+
+int sceRtcGetWin32FileTime(const RtcDateTime* time, uint64_t* win32_time) {
+ (void)time;
+ (void)win32_time;
+ return 0;
+}
+
+int sceRtcIsLeapYear(int year) {
+ (void)year;
+ return 0;
+}
+
+int sceRtcParseRFC3339(RtcTick* utc, const char* date_time) {
+ (void)utc;
+ (void)date_time;
+ return 0;
+}
+
+int sceRtcSetTick(RtcDateTime* time, const RtcTick* tick) {
+ (void)time;
+ (void)tick;
+ return 0;
+}
+
+int sceRtcSetTime_t(RtcDateTime* time, int64_t seconds) {
+ (void)time;
+ (void)seconds;
+ return 0;
+}
+
+int sceRtcSetWin32FileTime(RtcDateTime* time, uint64_t win32_time) {
+ (void)time;
+ (void)win32_time;
+ return 0;
+}
+
+int sceRtcTickAddDays(RtcTick* dst, const RtcTick* src, int32_t days) {
+ (void)dst;
+ (void)src;
+ (void)days;
+ return 0;
+}
+
+int sceRtcTickAddHours(RtcTick* dst, const RtcTick* src, int32_t hours) {
+ (void)dst;
+ (void)src;
+ (void)hours;
+ return 0;
+}
+
+int sceRtcTickAddMicroseconds(RtcTick* dst, const RtcTick* src, int64_t usec) {
+ (void)dst;
+ (void)src;
+ (void)usec;
+ return 0;
+}
+
+int sceRtcTickAddMinutes(RtcTick* dst, const RtcTick* src, int64_t minutes) {
+ (void)dst;
+ (void)src;
+ (void)minutes;
+ return 0;
+}
+
+int sceRtcTickAddSeconds(RtcTick* dst, const RtcTick* src, int64_t seconds) {
+ (void)dst;
+ (void)src;
+ (void)seconds;
+ return 0;
+}
+
+int sceRtcTickAddTicks(RtcTick* dst, const RtcTick* src, int64_t ticks) {
+ (void)dst;
+ (void)src;
+ (void)ticks;
+ return 0;
+}
+
+int sceRtcTickAddWeeks(RtcTick* dst, const RtcTick* src, int32_t weeks) {
+ (void)dst;
+ (void)src;
+ (void)weeks;
+ return 0;
+}
+
+}

core/libs/prx/libSceRudp/Export.cpp

@@ -0,0 +1,25 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceRudpEnableInternalIOThread(uint32_t stack_size, uint32_t priority) {
+ (void)stack_size;
+ (void)priority;
+ return 0;
+}
+
+int sceRudpInit(void* mem_pool, int mem_pool_size) {
+ (void)mem_pool;
+ (void)mem_pool_size;
+ return 0;
+}
+
+int sceRudpSetEventHandler(RudpEventHandler handler, void* arg) {
+ (void)handler;
+ (void)arg;
+ return 0;
+}
+
+}

core/libs/prx/libSceSaveData.native/Export.cpp

@@ -0,0 +1,139 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceSaveDataBackup(const SaveDataBackup* backup) {
+ (void)backup;
+ return 0;
+}
+
+int sceSaveDataCommit(const SaveDataCommitParam* param) {
+ (void)param;
+ return 0;
+}
+
+int sceSaveDataCreateTransactionResource(uint32_t size) {
+ (void)size;
+ return 0;
+}
+
+int sceSaveDataDelete(const SaveDataDelete* del) {
+ (void)del;
+ return 0;
+}
+
+int sceSaveDataDeleteTransactionResource(int32_t resource) {
+ (void)resource;
+ return 0;
+}
+
+int sceSaveDataDirNameSearch(const SaveDataDirNameSearchCond* cond, SaveDataDirNameSearchResult* result) {
+ (void)cond;
+ (void)result;
+ return 0;
+}
+
+int sceSaveDataGetEventResult(const void* event_param, SaveDataEvent* event) {
+ (void)event_param;
+ (void)event;
+ return 0;
+}
+
+int sceSaveDataGetMountInfo(const SaveDataMountPoint* mount_point, SaveDataMountInfo* info) {
+ (void)mount_point;
+ (void)info;
+ return 0;
+}
+
+int sceSaveDataGetParam(const SaveDataMountPoint* mount_point, uint32_t param_type, void* param_buf, size_t param_buf_size, size_t* got_size) {
+ (void)mount_point;
+ (void)param_type;
+ (void)param_buf;
+ (void)param_buf_size;
+ (void)got_size;
+ return 0;
+}
+
+int sceSaveDataGetSaveDataMemory2(SaveDataMemoryGet2* get_param) {
+ (void)get_param;
+ return 0;
+}
+
+int sceSaveDataInitialize3(const void* init) {
+ (void)init;
+ return 0;
+}
+
+int sceSaveDataLoadIcon(const SaveDataMountPoint* mount_point, SaveDataIcon* icon) {
+ (void)mount_point;
+ (void)icon;
+ return 0;
+}
+
+int sceSaveDataMount3(const SaveDataMount3* mount, SaveDataMountResult* mount_result) {
+ (void)mount;
+ (void)mount_result;
+ return 0;
+}
+
+int sceSaveDataPrepare(const SaveDataMountPoint* mount_point, const SaveDataPrepareParam* param) {
+ (void)mount_point;
+ (void)param;
+ return 0;
+}
+
+int sceSaveDataSaveIcon(const SaveDataMountPoint* mount_point, const SaveDataIcon* icon) {
+ (void)mount_point;
+ (void)icon;
+ return 0;
+}
+
+int sceSaveDataSaveIconByPath(const SaveDataMountPoint* mount_point, const char* path) {
+ (void)mount_point;
+ (void)path;
+ return 0;
+}
+
+int sceSaveDataSetParam(const SaveDataMountPoint* mount_point, uint32_t param_type, const void* param_buf, size_t param_buf_size) {
+ (void)mount_point;
+ (void)param_type;
+ (void)param_buf;
+ (void)param_buf_size;
+ return 0;
+}
+
+int sceSaveDataSetSaveDataMemory2(const SaveDataMemorySet2* set_param) {
+ (void)set_param;
+ return 0;
+}
+
+int sceSaveDataSetupSaveDataMemory2(const SaveDataMemorySetup2* setup_param, SaveDataMemorySetupResult* result) {
+ (void)setup_param;
+ (void)result;
+ return 0;
+}
+
+int sceSaveDataSyncSaveDataMemory(const void* sync_param) {
+ (void)sync_param;
+ return 0;
+}
+
+int sceSaveDataTerminate(void) {
+ return 0;
+}
+
+int sceSaveDataTransferringMount(const SaveDataTransferringMount* mount, SaveDataMountResult* mount_result) {
+ (void)mount;
+ (void)mount_result;
+ return 0;
+}
+
+int sceSaveDataUmount2(uint32_t mode, const SaveDataMountPoint* mount_point) {
+ (void)mode;
+ (void)mount_point;
+ return 0;
+}
+
+}

core/libs/prx/libSceSaveData/Export.cpp

@@ -0,0 +1,100 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceSaveDataBackup(const SaveDataBackup* backup) {
+ (void)backup;
+ return 0;
+}
+
+int sceSaveDataDelete(const SaveDataDelete* del) {
+ (void)del;
+ return 0;
+}
+
+int sceSaveDataDirNameSearch(const SaveDataDirNameSearchCond* cond, SaveDataDirNameSearchResult* result) {
+ (void)cond;
+ (void)result;
+ return 0;
+}
+
+int sceSaveDataGetEventResult(const void* event_param, SaveDataEvent* event) {
+ (void)event_param;
+ (void)event;
+ return 0;
+}
+
+int sceSaveDataGetMountInfo(const SaveDataMountPoint* mount_point, SaveDataMountInfo* info) {
+ (void)mount_point;
+ (void)info;
+ return 0;
+}
+
+int sceSaveDataGetParam(const SaveDataMountPoint* mount_point, uint32_t param_type, void* param_buf, size_t param_buf_size, size_t* got_size) {
+ (void)mount_point;
+ (void)param_type;
+ (void)param_buf;
+ (void)param_buf_size;
+ (void)got_size;
+ return 0;
+}
+
+int sceSaveDataGetSaveDataMemory2(SaveDataMemoryGet2* get_param) {
+ (void)get_param;
+ return 0;
+}
+
+int sceSaveDataInitialize3(const void* init) {
+ (void)init;
+ return 0;
+}
+
+int sceSaveDataLoadIcon(const SaveDataMountPoint* mount_point, SaveDataIcon* icon) {
+ (void)mount_point;
+ (void)icon;
+ return 0;
+}
+
+int sceSaveDataSaveIcon(const SaveDataMountPoint* mount_point, const SaveDataIcon* icon) {
+ (void)mount_point;
+ (void)icon;
+ return 0;
+}
+
+int sceSaveDataSetParam(const SaveDataMountPoint* mount_point, uint32_t param_type, const void* param_buf, size_t param_buf_size) {
+ (void)mount_point;
+ (void)param_type;
+ (void)param_buf;
+ (void)param_buf_size;
+ return 0;
+}
+
+int sceSaveDataSetSaveDataMemory2(const SaveDataMemorySet2* set_param) {
+ (void)set_param;
+ return 0;
+}
+
+int sceSaveDataSetupSaveDataMemory2(const SaveDataMemorySetup2* setup_param, SaveDataMemorySetupResult* result) {
+ (void)setup_param;
+ (void)result;
+ return 0;
+}
+
+int sceSaveDataSyncSaveDataMemory(const void* sync_param) {
+ (void)sync_param;
+ return 0;
+}
+
+int sceSaveDataTerminate(void) {
+ return 0;
+}
+
+int sceSaveDataTransferringMount(const SaveDataTransferringMount* mount, SaveDataMountResult* mount_result) {
+ (void)mount;
+ (void)mount_result;
+ return 0;
+}
+
+}

core/libs/prx/libSceSaveDataDialog.native/Export.cpp

@@ -0,0 +1,54 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceSaveDataDialogClose(const void* close_param) {
+ (void)close_param;
+ return 0;
+}
+
+int sceSaveDataDialogGetResult(void* result) {
+ (void)result;
+ return 0;
+}
+
+int sceSaveDataDialogGetStatus(void) {
+ return 0;
+}
+
+int sceSaveDataDialogInitialize(void) {
+ return 0;
+}
+
+int sceSaveDataDialogIsReadyToDisplay(void) {
+ return 0;
+}
+
+int sceSaveDataDialogOpen(const void* param) {
+ (void)param;
+ return 0;
+}
+
+int sceSaveDataDialogProgressBarInc(int target, uint32_t delta) {
+ (void)target;
+ (void)delta;
+ return 0;
+}
+
+int sceSaveDataDialogProgressBarSetValue(int target, uint32_t rate) {
+ (void)target;
+ (void)rate;
+ return 0;
+}
+
+int sceSaveDataDialogTerminate(void) {
+ return 0;
+}
+
+int sceSaveDataDialogUpdateStatus(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceSaveDataDialog/Export.cpp

@@ -0,0 +1,54 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceSaveDataDialogClose(const void* close_param) {
+ (void)close_param;
+ return 0;
+}
+
+int sceSaveDataDialogGetResult(void* result) {
+ (void)result;
+ return 0;
+}
+
+int sceSaveDataDialogGetStatus(void) {
+ return 0;
+}
+
+int sceSaveDataDialogInitialize(void) {
+ return 0;
+}
+
+int sceSaveDataDialogIsReadyToDisplay(void) {
+ return 0;
+}
+
+int sceSaveDataDialogOpen(const void* param) {
+ (void)param;
+ return 0;
+}
+
+int sceSaveDataDialogProgressBarInc(int target, uint32_t delta) {
+ (void)target;
+ (void)delta;
+ return 0;
+}
+
+int sceSaveDataDialogProgressBarSetValue(int target, uint32_t rate) {
+ (void)target;
+ (void)rate;
+ return 0;
+}
+
+int sceSaveDataDialogTerminate(void) {
+ return 0;
+}
+
+int sceSaveDataDialogUpdateStatus(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceShare.native/Export.cpp

@@ -0,0 +1,81 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceShareCaptureScreenshot(const void* param, int32_t* req_id) {
+ (void)param;
+ (void)req_id;
+ return 0;
+}
+
+int sceShareCaptureVideoClip(const void* param, int32_t* req_id) {
+ (void)param;
+ (void)req_id;
+ return 0;
+}
+
+int sceShareFeaturePermit(uint32_t feature_flags) {
+ (void)feature_flags;
+ return 0;
+}
+
+int sceShareFeatureProhibit(uint32_t feature_flags) {
+ (void)feature_flags;
+ return 0;
+}
+
+int sceShareGetCurrentStatus(uint32_t feature_flag, ShareCurrentStatus* status) {
+ (void)feature_flag;
+ (void)status;
+ return 0;
+}
+
+int sceShareInitialize(size_t heap_size, int thread_priority, uint64_t affinity_mask) {
+ (void)heap_size;
+ (void)thread_priority;
+ (void)affinity_mask;
+ return 0;
+}
+
+int sceShareOpenMenuForContent(const void* content_id) {
+ (void)content_id;
+ return 0;
+}
+
+int sceShareRegisterContentEventCallback(void* callback, void* user_data) {
+ (void)callback;
+ (void)user_data;
+ return 0;
+}
+
+int sceShareSetCaptureSource(uint32_t feature_flags, const void* tap_point) {
+ (void)feature_flags;
+ (void)tap_point;
+ return 0;
+}
+
+int sceShareSetContentParam(const char* content_param) {
+ (void)content_param;
+ return 0;
+}
+
+int sceShareSetScreenshotOverlayImage(const char* file_path, int32_t margin_x, int32_t margin_y, int32_t origin) {
+ (void)file_path;
+ (void)margin_x;
+ (void)margin_y;
+ (void)origin;
+ return 0;
+}
+
+int sceShareTerminate(void) {
+ return 0;
+}
+
+int sceShareUnregisterContentEventCallback(void* callback) {
+ (void)callback;
+ return 0;
+}
+
+}

core/libs/prx/libSceSharePlay/Export.cpp

@@ -0,0 +1,17 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceSharePlayInitialize(void* heap, size_t heap_size) {
+ (void)heap;
+ (void)heap_size;
+ return 0;
+}
+
+int sceSharePlayTerminate(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceSigninDialog/Export.cpp

@@ -0,0 +1,37 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceSigninDialogClose(void) {
+ return 0;
+}
+
+int sceSigninDialogGetResult(void* result) {
+ (void)result;
+ return 0;
+}
+
+int sceSigninDialogGetStatus(void) {
+ return 0;
+}
+
+int sceSigninDialogInitialize(void) {
+ return 0;
+}
+
+int sceSigninDialogOpen(const void* param) {
+ (void)param;
+ return 0;
+}
+
+int sceSigninDialogTerminate(void) {
+ return 0;
+}
+
+int sceSigninDialogUpdateStatus(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceSsl/Export.cpp

@@ -0,0 +1,29 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceSslFreeCaCerts(int ssl_ctx_id, void* ca_certs) {
+ (void)ssl_ctx_id;
+ (void)ca_certs;
+ return 0;
+}
+
+int sceSslGetCaCerts(int ssl_ctx_id, void* ca_certs) {
+ (void)ssl_ctx_id;
+ (void)ca_certs;
+ return 0;
+}
+
+int sceSslInit(uint64_t pool_size) {
+ (void)pool_size;
+ return 0;
+}
+
+int sceSslTerm(int ssl_ctx_id) {
+ (void)ssl_ctx_id;
+ return 0;
+}
+
+}

core/libs/prx/libSceSysmodule/Export.cpp

@@ -0,0 +1,38 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceSysmoduleGetModuleInfoForUnwind(uint64_t addr, int flags, ModuleInfoForUnwind* info) {
+ (void)addr;
+ (void)flags;
+ (void)info;
+ return 0;
+}
+
+int sceSysmoduleIsLoaded(uint16_t id) {
+ (void)id;
+ return 0;
+}
+
+int sceSysmoduleLoadModule(uint16_t id) {
+ (void)id;
+ return 0;
+}
+
+int sceSysmoduleLoadModuleInternalWithArg(uint16_t id, int arg1, int arg2, int arg3, int* ret) {
+ (void)id;
+ (void)arg1;
+ (void)arg2;
+ (void)arg3;
+ (void)ret;
+ return 0;
+}
+
+int sceSysmoduleUnloadModule(uint16_t id) {
+ (void)id;
+ return 0;
+}
+
+}

core/libs/prx/libSceSystemGesture/Export.cpp

@@ -0,0 +1,144 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceSystemGestureAppendTouchRecognizer(int32_t gesture_handle, SystemGestureTouchRecognizer* recognizer) {
+ (void)gesture_handle;
+ (void)recognizer;
+ return 0;
+}
+
+int sceSystemGestureClose(int32_t gesture_handle) {
+ (void)gesture_handle;
+ return 0;
+}
+
+int sceSystemGestureCreateTouchRecognizer(int32_t gesture_handle, SystemGestureTouchRecognizer* recognizer, int32_t, const SystemGestureRectangle*, const void*) {
+ (void)gesture_handle;
+ (void)recognizer;
+ (void)int32_t;
+ (void)SystemGestureRectangle;
+ return 0;
+}
+
+int sceSystemGestureFinalizePrimitiveTouchRecognizer(void) {
+ return 0;
+}
+
+int sceSystemGestureGetPrimitiveTouchEventByIndex(int32_t gesture_handle, uint32_t, SystemGesturePrimitiveTouchEvent* event) {
+ (void)gesture_handle;
+ (void)uint32_t;
+ (void)event;
+ return 0;
+}
+
+int sceSystemGestureGetPrimitiveTouchEventByPrimitiveID(int32_t gesture_handle, uint16_t, SystemGesturePrimitiveTouchEvent* event) {
+ (void)gesture_handle;
+ (void)uint16_t;
+ (void)event;
+ return 0;
+}
+
+int sceSystemGestureGetPrimitiveTouchEvents(int32_t gesture_handle, SystemGesturePrimitiveTouchEvent* event_buffer, uint32_t capacity_of_buffer, uint32_t* number_of_event) {
+ (void)gesture_handle;
+ (void)event_buffer;
+ (void)capacity_of_buffer;
+ (void)number_of_event;
+ return 0;
+}
+
+int sceSystemGestureGetPrimitiveTouchEventsCount(int32_t gesture_handle) {
+ (void)gesture_handle;
+ return 0;
+}
+
+int sceSystemGestureGetTouchEventByEventID(int32_t gesture_handle, const SystemGestureTouchRecognizer* recognizer, uint32_t, SystemGestureTouchEvent* event) {
+ (void)gesture_handle;
+ (void)recognizer;
+ (void)uint32_t;
+ (void)event;
+ return 0;
+}
+
+int sceSystemGestureGetTouchEventByIndex(int32_t gesture_handle, const SystemGestureTouchRecognizer* recognizer, uint32_t, SystemGestureTouchEvent* event) {
+ (void)gesture_handle;
+ (void)recognizer;
+ (void)uint32_t;
+ (void)event;
+ return 0;
+}
+
+int sceSystemGestureGetTouchEvents(int32_t gesture_handle, const SystemGestureTouchRecognizer* recognizer, SystemGestureTouchEvent* event_buffer, uint32_t capacity_of_buffer, uint32_t* number_of_event) {
+ (void)gesture_handle;
+ (void)recognizer;
+ (void)event_buffer;
+ (void)capacity_of_buffer;
+ (void)number_of_event;
+ return 0;
+}
+
+int sceSystemGestureGetTouchEventsCount(int32_t gesture_handle, const SystemGestureTouchRecognizer* recognizer) {
+ (void)gesture_handle;
+ (void)recognizer;
+ return 0;
+}
+
+int sceSystemGestureGetTouchRecognizerInformation(int32_t gesture_handle, const SystemGestureTouchRecognizer* recognizer, SystemGestureTouchRecognizerInformation* information) {
+ (void)gesture_handle;
+ (void)recognizer;
+ (void)information;
+ return 0;
+}
+
+int sceSystemGestureInitializePrimitiveTouchRecognizer(const void*) {
+ return 0;
+}
+
+int32_t sceSystemGestureOpen(int32_t input_type, const void*) {
+ (void)input_type;
+ return 0;
+}
+
+int sceSystemGestureRemoveTouchRecognizer(int32_t gesture_handle, SystemGestureTouchRecognizer* recognizer) {
+ (void)gesture_handle;
+ (void)recognizer;
+ return 0;
+}
+
+int sceSystemGestureResetPrimitiveTouchRecognizer(int32_t gesture_handle) {
+ (void)gesture_handle;
+ return 0;
+}
+
+int sceSystemGestureResetTouchRecognizer(int32_t gesture_handle, SystemGestureTouchRecognizer* recognizer) {
+ (void)gesture_handle;
+ (void)recognizer;
+ return 0;
+}
+
+int sceSystemGestureUpdateAllTouchRecognizer(int32_t gesture_handle) {
+ (void)gesture_handle;
+ return 0;
+}
+
+int sceSystemGestureUpdatePrimitiveTouchRecognizer(int32_t gesture_handle, const void*) {
+ (void)gesture_handle;
+ return 0;
+}
+
+int sceSystemGestureUpdateTouchRecognizer(int32_t gesture_handle, SystemGestureTouchRecognizer* recognizer) {
+ (void)gesture_handle;
+ (void)recognizer;
+ return 0;
+}
+
+int sceSystemGestureUpdateTouchRecognizerRectangle(int32_t gesture_handle, SystemGestureTouchRecognizer* recognizer, const SystemGestureRectangle* rectangle) {
+ (void)gesture_handle;
+ (void)recognizer;
+ (void)rectangle;
+ return 0;
+}
+
+}

core/libs/prx/libSceSystemService/Export.cpp

@@ -0,0 +1,66 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceSystemServiceDisableNoticeScreenSkipFlagAutoSet(void) {
+ return 0;
+}
+
+int sceSystemServiceGetDisplaySafeAreaInfo(SystemServiceDisplaySafeAreaInfo* info) {
+ (void)info;
+ return 0;
+}
+
+int sceSystemServiceGetHdrToneMapLuminance(SystemServiceHdrToneMapLuminance* luminance) {
+ (void)luminance;
+ return 0;
+}
+
+int sceSystemServiceGetNoticeScreenSkipFlag(bool* value) {
+ (void)value;
+ return 0;
+}
+
+int sceSystemServiceGetStatus(SystemServiceStatus* status) {
+ (void)status;
+ return 0;
+}
+
+int sceSystemServiceHideSplashScreen(void) {
+ return 0;
+}
+
+int sceSystemServiceParamGetInt(int param_id, int* value) {
+ (void)param_id;
+ (void)value;
+ return 0;
+}
+
+int sceSystemServiceParamGetString(int param_id, char* buf, size_t buf_size) {
+ (void)param_id;
+ (void)buf;
+ (void)buf_size;
+ return 0;
+}
+
+int sceSystemServicePowerTick(void) {
+ return 0;
+}
+
+int sceSystemServiceReceiveEvent(SystemServiceEvent* event) {
+ (void)event;
+ return 0;
+}
+
+int sceSystemServiceReportAbnormalTermination(const void* info) {
+ (void)info;
+ return 0;
+}
+
+int sceSystemServiceSetNoticeScreenSkipFlag(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceUlt/Export.cpp

@@ -0,0 +1,175 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceUltFinalize(void) {
+ return 0;
+}
+
+int sceUltInitialize(void) {
+ return 0;
+}
+
+int sceUltMutexCreate(void* mutex, const char* name, void* waiting_queue_resource_pool, const UltMutexOptParam* opt_param, uint32_t build_version) {
+ (void)mutex;
+ (void)name;
+ (void)waiting_queue_resource_pool;
+ (void)opt_param;
+ (void)build_version;
+ return 0;
+}
+
+int sceUltMutexLock(void* mutex) {
+ (void)mutex;
+ return 0;
+}
+
+int sceUltMutexOptParamInitialize(UltMutexOptParam* opt_param, uint32_t build_version) {
+ (void)opt_param;
+ (void)build_version;
+ return 0;
+}
+
+int sceUltMutexUnlock(void* mutex) {
+ (void)mutex;
+ return 0;
+}
+
+int sceUltQueueCreate(void* queue, const char* name, uint64_t data_size, void* waiting_queue_resource_pool, void* queue_data_resource_pool, const void* opt_param, uint32_t build_version) {
+ (void)queue;
+ (void)name;
+ (void)data_size;
+ (void)waiting_queue_resource_pool;
+ (void)queue_data_resource_pool;
+ (void)opt_param;
+ (void)build_version;
+ return 0;
+}
+
+int sceUltQueueDataResourcePoolCreate(void* pool, const char* name, uint32_t num_data, uint64_t data_size, uint32_t num_queue_object, void* waiting_queue_resource_pool, void* work_area, const void* opt_param, uint32_t build_version) {
+ (void)pool;
+ (void)name;
+ (void)num_data;
+ (void)data_size;
+ (void)num_queue_object;
+ (void)waiting_queue_resource_pool;
+ (void)work_area;
+ (void)opt_param;
+ (void)build_version;
+ return 0;
+}
+
+uint64_t sceUltQueueDataResourcePoolGetWorkAreaSize(uint32_t num_data, uint64_t data_size, uint32_t num_queue_object) {
+ (void)num_data;
+ (void)data_size;
+ (void)num_queue_object;
+ return 0;
+}
+
+int sceUltQueuePush(void* queue, const void* data) {
+ (void)queue;
+ (void)data;
+ return 0;
+}
+
+int sceUltQueueTryPop(void* queue, void* data) {
+ (void)queue;
+ (void)data;
+ return 0;
+}
+
+int sceUltSemaphoreAcquire(void* semaphore, int32_t num_resource) {
+ (void)semaphore;
+ (void)num_resource;
+ return 0;
+}
+
+int sceUltSemaphoreCreate(void* semaphore, const char* name, int32_t num_initial_resource, void* waiting_queue_resource_pool, const void* opt_param, uint32_t build_version) {
+ (void)semaphore;
+ (void)name;
+ (void)num_initial_resource;
+ (void)waiting_queue_resource_pool;
+ (void)opt_param;
+ (void)build_version;
+ return 0;
+}
+
+int sceUltSemaphoreDestroy(void* semaphore) {
+ (void)semaphore;
+ return 0;
+}
+
+int sceUltSemaphoreRelease(void* semaphore, int32_t num_resource) {
+ (void)semaphore;
+ (void)num_resource;
+ return 0;
+}
+
+int sceUltSemaphoreTryAcquire(void* semaphore, int32_t num_resource) {
+ (void)semaphore;
+ (void)num_resource;
+ return 0;
+}
+
+int sceUltUlthreadCreate(void* ulthread, const char* name, UltUlthreadEntry entry, uint64_t arg, void* context, uint64_t size_context, void* runtime, const void* opt_param, uint32_t build_version) {
+ (void)ulthread;
+ (void)name;
+ (void)entry;
+ (void)arg;
+ (void)context;
+ (void)size_context;
+ (void)runtime;
+ (void)opt_param;
+ (void)build_version;
+ return 0;
+}
+
+int sceUltUlthreadJoin(void* ulthread, int32_t* status) {
+ (void)ulthread;
+ (void)status;
+ return 0;
+}
+
+int sceUltUlthreadRuntimeCreate(void* runtime, const char* name, uint32_t max_num_ulthread, uint32_t num_worker_thread, void* work_area, const void* opt_param, uint32_t build_version) {
+ (void)runtime;
+ (void)name;
+ (void)max_num_ulthread;
+ (void)num_worker_thread;
+ (void)work_area;
+ (void)opt_param;
+ (void)build_version;
+ return 0;
+}
+
+uint64_t sceUltUlthreadRuntimeGetWorkAreaSize(uint32_t max_num_ulthread, uint32_t num_worker_thread) {
+ (void)max_num_ulthread;
+ (void)num_worker_thread;
+ return 0;
+}
+
+int sceUltUlthreadRuntimeOptParamInitialize(UltUlthreadRuntimeOptParam* opt_param, uint32_t build_version) {
+ (void)opt_param;
+ (void)build_version;
+ return 0;
+}
+
+int sceUltWaitingQueueResourcePoolCreate(void* pool, const char* name, uint32_t num_threads, uint32_t num_sync_objects, void* work_area, const void* opt_param, uint32_t build_version) {
+ (void)pool;
+ (void)name;
+ (void)num_threads;
+ (void)num_sync_objects;
+ (void)work_area;
+ (void)opt_param;
+ (void)build_version;
+ return 0;
+}
+
+uint64_t sceUltWaitingQueueResourcePoolGetWorkAreaSize(uint32_t num_threads, uint32_t num_sync_objects) {
+ (void)num_threads;
+ (void)num_sync_objects;
+ return 0;
+}
+
+}

core/libs/prx/libSceUserService/Export.cpp

@@ -0,0 +1,86 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceUserServiceGetAccessibilityChatTranscription(int user_id, int32_t* chat_transcription) {
+ (void)user_id;
+ (void)chat_transcription;
+ return 0;
+}
+
+int sceUserServiceGetAccessibilityPressAndHoldDelay(int user_id, int32_t* press_and_hold_delay) {
+ (void)user_id;
+ (void)press_and_hold_delay;
+ return 0;
+}
+
+int sceUserServiceGetAccessibilityTriggerEffect(int user_id, int32_t* trigger_effect) {
+ (void)user_id;
+ (void)trigger_effect;
+ return 0;
+}
+
+int sceUserServiceGetAccessibilityVibration(int user_id, int32_t* vibration) {
+ (void)user_id;
+ (void)vibration;
+ return 0;
+}
+
+int sceUserServiceGetAccessibilityZoomEnabled(int user_id, int32_t* zoom_enabled) {
+ (void)user_id;
+ (void)zoom_enabled;
+ return 0;
+}
+
+int sceUserServiceGetAgeLevel(int user_id, uint32_t* age_level) {
+ (void)user_id;
+ (void)age_level;
+ return 0;
+}
+
+int sceUserServiceGetEvent(SceUserServiceEvent* event) {
+ (void)event;
+ return 0;
+}
+
+int sceUserServiceGetGamePresets(int user_id, UserServiceGamePresets* presets) {
+ (void)user_id;
+ (void)presets;
+ return 0;
+}
+
+int sceUserServiceGetInitialUser(int* user_id) {
+ (void)user_id;
+ return 0;
+}
+
+int sceUserServiceGetLoginUserIdList(UserServiceLoginUserIdList* user_id_list) {
+ (void)user_id_list;
+ return 0;
+}
+
+int sceUserServiceGetUserName(int user_id, char* name, size_t size) {
+ (void)user_id;
+ (void)name;
+ (void)size;
+ return 0;
+}
+
+int sceUserServiceGetUserNumber(int user_id, int32_t* number) {
+ (void)user_id;
+ (void)number;
+ return 0;
+}
+
+int sceUserServiceInitialize(const void* params) {
+ (void)params;
+ return 0;
+}
+
+int sceUserServiceInitialize2(void) {
+ return 0;
+}
+
+}

core/libs/prx/libSceVideoOut/Export.cpp

@@ -0,0 +1,191 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceVideoOutAddFlipEvent(KernelEqueue eq, int handle, void* udata) {
+ (void)eq;
+ (void)handle;
+ (void)udata;
+ return 0;
+}
+
+int sceVideoOutAddOutputModeEvent(KernelEqueue eq, int handle, void* udata) {
+ (void)eq;
+ (void)handle;
+ (void)udata;
+ return 0;
+}
+
+int sceVideoOutAddPreVblankStartEvent(KernelEqueue eq, int handle, void* udata) {
+ (void)eq;
+ (void)handle;
+ (void)udata;
+ return 0;
+}
+
+int sceVideoOutAddVblankEvent(KernelEqueue eq, int handle, void* udata) {
+ (void)eq;
+ (void)handle;
+ (void)udata;
+ return 0;
+}
+
+int sceVideoOutClose(int handle) {
+ (void)handle;
+ return 0;
+}
+
+int sceVideoOutConfigureOutput(int handle, uint64_t mode, const VideoOutOutputOptions* options, void* reserved_ptr, uint64_t reserved) {
+ (void)handle;
+ (void)mode;
+ (void)options;
+ (void)reserved_ptr;
+ (void)reserved;
+ return 0;
+}
+
+int sceVideoOutDeleteFlipEvent(KernelEqueue eq, int handle) {
+ (void)eq;
+ (void)handle;
+ return 0;
+}
+
+int sceVideoOutDeletePreVblankStartEvent(KernelEqueue eq, int handle) {
+ (void)eq;
+ (void)handle;
+ return 0;
+}
+
+int sceVideoOutDeleteVblankEvent(KernelEqueue eq, int handle) {
+ (void)eq;
+ (void)handle;
+ return 0;
+}
+
+int sceVideoOutGetEventCount(const KernelEvent* ev) {
+ (void)ev;
+ return 0;
+}
+
+int sceVideoOutGetEventData(const KernelEvent* ev, int64_t* data) {
+ (void)ev;
+ (void)data;
+ return 0;
+}
+
+int sceVideoOutGetEventId(const KernelEvent* ev) {
+ (void)ev;
+ return 0;
+}
+
+int sceVideoOutGetFlipStatus(int handle, VideoOutFlipStatus* status) {
+ (void)handle;
+ (void)status;
+ return 0;
+}
+
+int sceVideoOutGetOutputStatus(int handle, VideoOutOutputStatus* status) {
+ (void)handle;
+ (void)status;
+ return 0;
+}
+
+int sceVideoOutGetVblankStatus(int handle, VideoOutVblankStatus* status) {
+ (void)handle;
+ (void)status;
+ return 0;
+}
+
+int sceVideoOutInitializeOutputOptions(VideoOutOutputOptions* options) {
+ (void)options;
+ return 0;
+}
+
+int sceVideoOutIsFlipPending(int handle) {
+ (void)handle;
+ return 0;
+}
+
+int sceVideoOutIsOutputSupported(int handle, uint64_t mode, const VideoOutOutputOptions* options, void* reserved_ptr, uint64_t reserved) {
+ (void)handle;
+ (void)mode;
+ (void)options;
+ (void)reserved_ptr;
+ (void)reserved;
+ return 0;
+}
+
+int sceVideoOutOpen(int user_id, int bus_type, int index, const void* param) {
+ (void)user_id;
+ (void)bus_type;
+ (void)index;
+ (void)param;
+ return 0;
+}
+
+int sceVideoOutRegisterBuffers2(int handle, int set_index, int buffer_index_start, const VideoOutBuffers* buffers, int buffer_num, const VideoOutBufferAttribute2* attribute, int category, void* option) {
+ (void)handle;
+ (void)set_index;
+ (void)buffer_index_start;
+ (void)buffers;
+ (void)buffer_num;
+ (void)attribute;
+ (void)category;
+ (void)option;
+ return 0;
+}
+
+void sceVideoOutSetBufferAttribute2(VideoOutBufferAttribute2* attribute, uint64_t pixel_format, uint32_t tiling_mode, uint32_t width, uint32_t height, uint64_t option, uint32_t dcc_control, uint64_t dcc_cb_register_clear_color) {
+ (void)attribute;
+ (void)pixel_format;
+ (void)tiling_mode;
+ (void)width;
+ (void)height;
+ (void)option;
+ (void)dcc_control;
+ (void)dcc_cb_register_clear_color;
+}
+
+int sceVideoOutSetFlipRate(int handle, int rate) {
+ (void)handle;
+ (void)rate;
+ return 0;
+}
+
+int sceVideoOutSetWindowModeMargins(int handle, int top, int bottom) {
+ (void)handle;
+ (void)top;
+ (void)bottom;
+ return 0;
+}
+
+int sceVideoOutSubmitChangeBufferAttribute2(int handle, int set_index, const VideoOutBufferAttribute2* attribute, void* option) {
+ (void)handle;
+ (void)set_index;
+ (void)attribute;
+ (void)option;
+ return 0;
+}
+
+int sceVideoOutSubmitFlip(int handle, int index, int flip_mode, int64_t flip_arg) {
+ (void)handle;
+ (void)index;
+ (void)flip_mode;
+ (void)flip_arg;
+ return 0;
+}
+
+int sceVideoOutUnregisterBuffers(int handle, int set_index) {
+ (void)handle;
+ (void)set_index;
+ return 0;
+}
+
+int sceVideoOutWaitVblank(int handle) {
+ (void)handle;
+ return 0;
+}
+
+}

core/libs/prx/libSceVoice/Export.cpp

@@ -0,0 +1,101 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceVoiceConnectIPortToOPort(uint32_t input_port_id, uint32_t output_port_id) {
+ (void)input_port_id;
+ (void)output_port_id;
+ return 0;
+}
+
+int sceVoiceCreatePort(uint32_t* port_id, const VoicePortParam* param) {
+ (void)port_id;
+ (void)param;
+ return 0;
+}
+
+int sceVoiceDeletePort(uint32_t port_id) {
+ (void)port_id;
+ return 0;
+}
+
+int sceVoiceDisconnectIPortFromOPort(uint32_t input_port_id, uint32_t output_port_id) {
+ (void)input_port_id;
+ (void)output_port_id;
+ return 0;
+}
+
+int sceVoiceEnd(void) {
+ return 0;
+}
+
+int sceVoiceGetBitRate(uint32_t port_id, uint32_t* bitrate) {
+ (void)port_id;
+ (void)bitrate;
+ return 0;
+}
+
+int sceVoiceGetPortAttr(uint32_t port_id, int32_t attr, void* value, int32_t size) {
+ (void)port_id;
+ (void)attr;
+ (void)value;
+ (void)size;
+ return 0;
+}
+
+int sceVoiceGetPortInfo(uint32_t port_id, VoicePortInfo* info) {
+ (void)port_id;
+ (void)info;
+ return 0;
+}
+
+int sceVoiceGetVolume(uint32_t port_id, float* volume) {
+ (void)port_id;
+ (void)volume;
+ return 0;
+}
+
+int sceVoiceInit(VoiceInitParam* param, int32_t version) {
+ (void)param;
+ (void)version;
+ return 0;
+}
+
+int sceVoiceReadFromOPort(uint32_t output_port_id, void* data, uint32_t* size) {
+ (void)output_port_id;
+ (void)data;
+ (void)size;
+ return 0;
+}
+
+int sceVoiceSetThreadsParams(void* params) {
+ (void)params;
+ return 0;
+}
+
+int sceVoiceSetVolume(uint32_t port_id, float volume) {
+ (void)port_id;
+ (void)volume;
+ return 0;
+}
+
+int sceVoiceStart(const VoiceStartParam* param) {
+ (void)param;
+ return 0;
+}
+
+int sceVoiceStop(void) {
+ return 0;
+}
+
+int sceVoiceWriteToIPort(uint32_t input_port_id, const void* data, uint32_t* size, int16_t frame_gaps) {
+ (void)input_port_id;
+ (void)data;
+ (void)size;
+ (void)frame_gaps;
+ return 0;
+}
+
+}

core/libs/prx/libSceVoiceQoS/Export.cpp

@@ -0,0 +1,14 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceVoiceQoSInit(void* mem_block, uint32_t mem_size, int32_t app_type) {
+ (void)mem_block;
+ (void)mem_size;
+ (void)app_type;
+ return 0;
+}
+
+}

core/libs/prx/libSceWebBrowserDialog/Export.cpp

@@ -0,0 +1,15 @@
+#include <cstdint>
+#include <cstddef>
+#include "SceTypes.hpp"
+
+extern "C" {
+
+int sceWebBrowserDialogInitialize(void) {
+ return 0;
+}
+
+int sceWebBrowserDialogTerminate(void) {
+ return 0;
+}
+
+}