void fmt_class_string<psf::format>::format(std::string& out, u64 arg)
{
format_enum(out, arg, [](auto fmt)
{
switch (fmt)
{
STR_CASE(psf::format::array);
STR_CASE(psf::format::string);
STR_CASE(psf::format::integer);
}
return unknown;
});
}
void fmt_class_string<CellDiscGameError>::format(std::string& out, u64 arg)
{
format_enum(out, arg, [](auto error)
{
switch (error)
{
STR_CASE(CELL_DISCGAME_ERROR_INTERNAL);
STR_CASE(CELL_DISCGAME_ERROR_NOT_DISCBOOT);
STR_CASE(CELL_DISCGAME_ERROR_PARAM);
}
return unknown;
});
}
void fmt_class_string<CellUserInfoError>::format(std::string& out, u64 arg)
{
format_enum(out, arg, [](auto error)
{
switch (error)
{
STR_CASE(CELL_USERINFO_ERROR_BUSY);
STR_CASE(CELL_USERINFO_ERROR_INTERNAL);
STR_CASE(CELL_USERINFO_ERROR_PARAM);
STR_CASE(CELL_USERINFO_ERROR_NOUSER);
}
return unknown;
});
}
void fmt_class_string<ScePerfError>::format(std::string& out, u64 arg)
{
format_enum(out, arg, [](auto error)
{
switch (error)
{
STR_CASE(SCE_PERF_ERROR_INVALID_ARGUMENT);
}
return unknown;
});
}
void fmt_class_string<CellPadError>::format(std::string& out, u64 arg)
{
format_enum(out, arg, [](auto error)
{
switch (error)
{
STR_CASE(CELL_PAD_ERROR_FATAL);
STR_CASE(CELL_PAD_ERROR_INVALID_PARAMETER);
STR_CASE(CELL_PAD_ERROR_ALREADY_INITIALIZED);
STR_CASE(CELL_PAD_ERROR_UNINITIALIZED);
STR_CASE(CELL_PAD_ERROR_RESOURCE_ALLOCATION_FAILED);
STR_CASE(CELL_PAD_ERROR_DATA_READ_FAILED);
STR_CASE(CELL_PAD_ERROR_NO_DEVICE);
STR_CASE(CELL_PAD_ERROR_UNSUPPORTED_GAMEPAD);
STR_CASE(CELL_PAD_ERROR_TOO_MANY_DEVICES);
STR_CASE(CELL_PAD_ERROR_EBUSY);
}
return unknown;
});
}
void fmt_class_string<CellVideoOutError>::format(std::string& out, u64 arg)
{
format_enum(out, arg, [](auto error)
{
switch (error)
{
STR_CASE(CELL_VIDEO_OUT_ERROR_NOT_IMPLEMENTED);
STR_CASE(CELL_VIDEO_OUT_ERROR_ILLEGAL_CONFIGURATION);
STR_CASE(CELL_VIDEO_OUT_ERROR_ILLEGAL_PARAMETER);
STR_CASE(CELL_VIDEO_OUT_ERROR_PARAMETER_OUT_OF_RANGE);
STR_CASE(CELL_VIDEO_OUT_ERROR_DEVICE_NOT_FOUND);
STR_CASE(CELL_VIDEO_OUT_ERROR_UNSUPPORTED_VIDEO_OUT);
STR_CASE(CELL_VIDEO_OUT_ERROR_UNSUPPORTED_DISPLAY_MODE);
STR_CASE(CELL_VIDEO_OUT_ERROR_CONDITION_BUSY);
STR_CASE(CELL_VIDEO_OUT_ERROR_VALUE_IS_NOT_SET);
}
return unknown;
});
}
void fmt_class_string<cpu_flag>::format(std::string& out, u64 arg)
{
format_enum(out, arg, [](cpu_flag f)
{
switch (f)
{
STR_CASE(cpu_flag::stop);
STR_CASE(cpu_flag::exit);
STR_CASE(cpu_flag::suspend);
STR_CASE(cpu_flag::ret);
STR_CASE(cpu_flag::signal);
STR_CASE(cpu_flag::dbg_global_pause);
STR_CASE(cpu_flag::dbg_global_stop);
STR_CASE(cpu_flag::dbg_pause);
STR_CASE(cpu_flag::dbg_step);
case cpu_flag::__bitset_enum_max: break;
}
return unknown;
});
}
void fmt_class_string<CellKbError>::format(std::string& out, u64 arg)
{
format_enum(out, arg, [](auto error)
{
switch (error)
{
STR_CASE(CELL_KB_ERROR_FATAL);
STR_CASE(CELL_KB_ERROR_INVALID_PARAMETER);
STR_CASE(CELL_KB_ERROR_ALREADY_INITIALIZED);
STR_CASE(CELL_KB_ERROR_UNINITIALIZED);
STR_CASE(CELL_KB_ERROR_RESOURCE_ALLOCATION_FAILED);
STR_CASE(CELL_KB_ERROR_READ_FAILED);
STR_CASE(CELL_KB_ERROR_NO_DEVICE);
STR_CASE(CELL_KB_ERROR_SYS_SETTING_FAILED);
}
return unknown;
});
}
void fmt_class_string<CellSubDisplayError>::format(std::string& out, u64 arg)
{
format_enum(out, arg, [](auto error)
{
switch (error)
{
STR_CASE(CELL_SUBDISPLAY_ERROR_OUT_OF_MEMORY);
STR_CASE(CELL_SUBDISPLAY_ERROR_FATAL);
STR_CASE(CELL_SUBDISPLAY_ERROR_NOT_FOUND);
STR_CASE(CELL_SUBDISPLAY_ERROR_INVALID_VALUE);
STR_CASE(CELL_SUBDISPLAY_ERROR_NOT_INITIALIZED);
STR_CASE(CELL_SUBDISPLAY_ERROR_SET_SAMPLE);
STR_CASE(CELL_SUBDISPLAY_ERROR_AUDIOOUT_IS_BUSY);
STR_CASE(CELL_SUBDISPLAY_ERROR_ZERO_REGISTERED);
}
return unknown;
});
}
void fmt_class_string<CellSysutilError>::format(std::string& out, u64 arg)
{
format_enum(out, arg, [](auto error)
{
switch (error)
{
STR_CASE(CELL_SYSUTIL_ERROR_TYPE);
STR_CASE(CELL_SYSUTIL_ERROR_VALUE);
STR_CASE(CELL_SYSUTIL_ERROR_SIZE);
STR_CASE(CELL_SYSUTIL_ERROR_NUM);
STR_CASE(CELL_SYSUTIL_ERROR_BUSY);
STR_CASE(CELL_SYSUTIL_ERROR_STATUS);
STR_CASE(CELL_SYSUTIL_ERROR_MEMORY);
}
return unknown;
});
}
void fmt_class_string<CellGameDataError>::format(std::string& out, u64 arg)
{
format_enum(out, arg, [](auto error)
{
switch (error)
{
STR_CASE(CELL_GAMEDATA_ERROR_CBRESULT);
STR_CASE(CELL_GAMEDATA_ERROR_ACCESS_ERROR);
STR_CASE(CELL_GAMEDATA_ERROR_INTERNAL);
STR_CASE(CELL_GAMEDATA_ERROR_PARAM);
STR_CASE(CELL_GAMEDATA_ERROR_NOSPACE);
STR_CASE(CELL_GAMEDATA_ERROR_BROKEN);
STR_CASE(CELL_GAMEDATA_ERROR_FAILURE);
}
return unknown;
});
}
void fmt_class_string<SceNpTrophyError>::format(std::string& out, u64 arg)
{
format_enum(out, arg, [](auto error)
{
switch (error)
{
STR_CASE(SCE_NP_TROPHY_ERROR_ALREADY_INITIALIZED);
STR_CASE(SCE_NP_TROPHY_ERROR_NOT_INITIALIZED);
STR_CASE(SCE_NP_TROPHY_ERROR_NOT_SUPPORTED);
STR_CASE(SCE_NP_TROPHY_ERROR_CONTEXT_NOT_REGISTERED);
STR_CASE(SCE_NP_TROPHY_ERROR_OUT_OF_MEMORY);
STR_CASE(SCE_NP_TROPHY_ERROR_INVALID_ARGUMENT);
STR_CASE(SCE_NP_TROPHY_ERROR_EXCEEDS_MAX);
STR_CASE(SCE_NP_TROPHY_ERROR_INSUFFICIENT);
STR_CASE(SCE_NP_TROPHY_ERROR_UNKNOWN_CONTEXT);
STR_CASE(SCE_NP_TROPHY_ERROR_INVALID_FORMAT);
STR_CASE(SCE_NP_TROPHY_ERROR_BAD_RESPONSE);
STR_CASE(SCE_NP_TROPHY_ERROR_INVALID_GRADE);
STR_CASE(SCE_NP_TROPHY_ERROR_INVALID_CONTEXT);
STR_CASE(SCE_NP_TROPHY_ERROR_PROCESSING_ABORTED);
STR_CASE(SCE_NP_TROPHY_ERROR_ABORT);
STR_CASE(SCE_NP_TROPHY_ERROR_UNKNOWN_HANDLE);
STR_CASE(SCE_NP_TROPHY_ERROR_LOCKED);
STR_CASE(SCE_NP_TROPHY_ERROR_HIDDEN);
STR_CASE(SCE_NP_TROPHY_ERROR_CANNOT_UNLOCK_PLATINUM);
STR_CASE(SCE_NP_TROPHY_ERROR_ALREADY_UNLOCKED);
STR_CASE(SCE_NP_TROPHY_ERROR_INVALID_TYPE);
STR_CASE(SCE_NP_TROPHY_ERROR_INVALID_HANDLE);
STR_CASE(SCE_NP_TROPHY_ERROR_INVALID_NP_COMM_ID);
STR_CASE(SCE_NP_TROPHY_ERROR_UNKNOWN_NP_COMM_ID);
STR_CASE(SCE_NP_TROPHY_ERROR_DISC_IO);
STR_CASE(SCE_NP_TROPHY_ERROR_CONF_DOES_NOT_EXIST);
STR_CASE(SCE_NP_TROPHY_ERROR_UNSUPPORTED_FORMAT);
STR_CASE(SCE_NP_TROPHY_ERROR_ALREADY_INSTALLED);
STR_CASE(SCE_NP_TROPHY_ERROR_BROKEN_DATA);
STR_CASE(SCE_NP_TROPHY_ERROR_VERIFICATION_FAILURE);
STR_CASE(SCE_NP_TROPHY_ERROR_INVALID_TROPHY_ID);
STR_CASE(SCE_NP_TROPHY_ERROR_UNKNOWN_TROPHY_ID);
STR_CASE(SCE_NP_TROPHY_ERROR_UNKNOWN_TITLE);
STR_CASE(SCE_NP_TROPHY_ERROR_UNKNOWN_FILE);
STR_CASE(SCE_NP_TROPHY_ERROR_DISC_NOT_MOUNTED);
STR_CASE(SCE_NP_TROPHY_ERROR_SHUTDOWN);
STR_CASE(SCE_NP_TROPHY_ERROR_TITLE_ICON_NOT_FOUND);
STR_CASE(SCE_NP_TROPHY_ERROR_TROPHY_ICON_NOT_FOUND);
STR_CASE(SCE_NP_TROPHY_ERROR_INSUFFICIENT_DISK_SPACE);
STR_CASE(SCE_NP_TROPHY_ERROR_ILLEGAL_UPDATE);
STR_CASE(SCE_NP_TROPHY_ERROR_SAVEDATA_USER_DOES_NOT_MATCH);
STR_CASE(SCE_NP_TROPHY_ERROR_TROPHY_ID_DOES_NOT_EXIST);
STR_CASE(SCE_NP_TROPHY_ERROR_SERVICE_UNAVAILABLE);
STR_CASE(SCE_NP_TROPHY_ERROR_UNKNOWN);
}
return unknown;
});
}
void fmt_class_string<CellAudioError>::format(std::string& out, u64 arg)
{
format_enum(out, arg, [](CellAudioError value)
{
switch (value)
{
STR_CASE(CELL_AUDIO_ERROR_ALREADY_INIT);
STR_CASE(CELL_AUDIO_ERROR_AUDIOSYSTEM);
STR_CASE(CELL_AUDIO_ERROR_NOT_INIT);
STR_CASE(CELL_AUDIO_ERROR_PARAM);
STR_CASE(CELL_AUDIO_ERROR_PORT_FULL);
STR_CASE(CELL_AUDIO_ERROR_PORT_ALREADY_RUN);
STR_CASE(CELL_AUDIO_ERROR_PORT_NOT_OPEN);
STR_CASE(CELL_AUDIO_ERROR_PORT_NOT_RUN);
STR_CASE(CELL_AUDIO_ERROR_TRANS_EVENT);
STR_CASE(CELL_AUDIO_ERROR_PORT_OPEN);
STR_CASE(CELL_AUDIO_ERROR_SHAREDMEMORY);
STR_CASE(CELL_AUDIO_ERROR_MUTEX);
STR_CASE(CELL_AUDIO_ERROR_EVENT_QUEUE);
STR_CASE(CELL_AUDIO_ERROR_AUDIOSYSTEM_NOT_FOUND);
STR_CASE(CELL_AUDIO_ERROR_TAG_NOT_FOUND);
}
return unknown;
});
}
void fmt_class_string<CellGameError>::format(std::string& out, u64 arg)
{
format_enum(out, arg, [](auto error)
{
switch (error)
{
STR_CASE(CELL_GAME_ERROR_NOTFOUND);
STR_CASE(CELL_GAME_ERROR_BROKEN);
STR_CASE(CELL_GAME_ERROR_INTERNAL);
STR_CASE(CELL_GAME_ERROR_PARAM);
STR_CASE(CELL_GAME_ERROR_NOAPP);
STR_CASE(CELL_GAME_ERROR_ACCESS_ERROR);
STR_CASE(CELL_GAME_ERROR_NOSPACE);
STR_CASE(CELL_GAME_ERROR_NOTSUPPORTED);
STR_CASE(CELL_GAME_ERROR_FAILURE);
STR_CASE(CELL_GAME_ERROR_BUSY);
STR_CASE(CELL_GAME_ERROR_IN_SHUTDOWN);
STR_CASE(CELL_GAME_ERROR_INVALID_ID);
STR_CASE(CELL_GAME_ERROR_EXIST);
STR_CASE(CELL_GAME_ERROR_NOTPATCH);
STR_CASE(CELL_GAME_ERROR_INVALID_THEME_FILE);
STR_CASE(CELL_GAME_ERROR_BOOTPATH);
}
return unknown;
});
}
void fmt_class_string<CellPrxError>::format(std::string& out, u64 arg)
{
format_enum(out, arg, [](CellPrxError value)
{
switch (value)
{
STR_CASE(CELL_PRX_ERROR_ERROR);
STR_CASE(CELL_PRX_ERROR_ILLEGAL_PERM);
STR_CASE(CELL_PRX_ERROR_UNKNOWN_MODULE);
STR_CASE(CELL_PRX_ERROR_ALREADY_STARTED);
STR_CASE(CELL_PRX_ERROR_NOT_STARTED);
STR_CASE(CELL_PRX_ERROR_ALREADY_STOPPED);
STR_CASE(CELL_PRX_ERROR_CAN_NOT_STOP);
STR_CASE(CELL_PRX_ERROR_NOT_REMOVABLE);
STR_CASE(CELL_PRX_ERROR_LIBRARY_NOT_YET_LINKED);
STR_CASE(CELL_PRX_ERROR_LIBRARY_FOUND);
STR_CASE(CELL_PRX_ERROR_LIBRARY_NOTFOUND);
STR_CASE(CELL_PRX_ERROR_ILLEGAL_LIBRARY);
STR_CASE(CELL_PRX_ERROR_LIBRARY_INUSE);
STR_CASE(CELL_PRX_ERROR_ALREADY_STOPPING);
STR_CASE(CELL_PRX_ERROR_UNSUPPORTED_PRX_TYPE);
STR_CASE(CELL_PRX_ERROR_INVAL);
STR_CASE(CELL_PRX_ERROR_ILLEGAL_PROCESS);
STR_CASE(CELL_PRX_ERROR_NO_LIBLV2);
STR_CASE(CELL_PRX_ERROR_UNSUPPORTED_ELF_TYPE);
STR_CASE(CELL_PRX_ERROR_UNSUPPORTED_ELF_CLASS);
STR_CASE(CELL_PRX_ERROR_UNDEFINED_SYMBOL);
STR_CASE(CELL_PRX_ERROR_UNSUPPORTED_RELOCATION_TYPE);
STR_CASE(CELL_PRX_ERROR_ELF_IS_REGISTERED);
}
return unknown;
});
}
char* _message_type_to_str (ldcs_message_ids_t type) {
switch (type) {
STR_CASE(LDCS_MSG_FILE_QUERY);
STR_CASE(LDCS_MSG_FILE_QUERY_ANSWER);
STR_CASE(LDCS_MSG_FILE_QUERY_EXACT_PATH);
STR_CASE(LDCS_MSG_FILE_REQUEST);
STR_CASE(LDCS_MSG_FILE_ERRCODE);
STR_CASE(LDCS_MSG_STAT_QUERY);
STR_CASE(LDCS_MSG_STAT_ANSWER);
STR_CASE(LDCS_MSG_STAT_NET_REQUEST);
STR_CASE(LDCS_MSG_STAT_NET_RESULT);
STR_CASE(LDCS_MSG_EXISTS_QUERY);
STR_CASE(LDCS_MSG_EXISTS_ANSWER);
STR_CASE(LDCS_MSG_ORIGPATH_QUERY);
STR_CASE(LDCS_MSG_ORIGPATH_ANSWER);
STR_CASE(LDCS_MSG_END);
STR_CASE(LDCS_MSG_CWD);
STR_CASE(LDCS_MSG_PID);
STR_CASE(LDCS_MSG_LOCATION);
STR_CASE(LDCS_MSG_MYRANKINFO_QUERY);
STR_CASE(LDCS_MSG_MYRANKINFO_QUERY_ANSWER);
STR_CASE(LDCS_MSG_CACHE_ENTRIES);
STR_CASE(LDCS_MSG_ACK);
STR_CASE(LDCS_MSG_DESTROY);
STR_CASE(LDCS_MSG_FILE_DATA);
STR_CASE(LDCS_MSG_FILE_DATA_PART);
STR_CASE(LDCS_MSG_PYTHONPREFIX_REQ);
STR_CASE(LDCS_MSG_PYTHONPREFIX_RESP);
STR_CASE(LDCS_MSG_LOADER_DATA_REQ);
STR_CASE(LDCS_MSG_LOADER_DATA_RESP);
STR_CASE(LDCS_MSG_LOADER_DATA_NET_REQ);
STR_CASE(LDCS_MSG_LOADER_DATA_NET_RESP);
STR_CASE(LDCS_MSG_MD_HOSTINFO);
STR_CASE(LDCS_MSG_MD_HOSTLIST);
STR_CASE(LDCS_MSG_MD_BOOTSTRAP);
STR_CASE(LDCS_MSG_MD_BOOTSTRAP_END);
STR_CASE(LDCS_MSG_MD_BOOTSTRAP_END_OK);
STR_CASE(LDCS_MSG_MD_BOOTSTRAP_END_NOT_OK);
STR_CASE(LDCS_MSG_PRELOAD_FILELIST);
STR_CASE(LDCS_MSG_PRELOAD_DIR);
STR_CASE(LDCS_MSG_PRELOAD_FILE);
STR_CASE(LDCS_MSG_PRELOAD_DONE);
STR_CASE(LDCS_MSG_SELFLOAD_FILE);
STR_CASE(LDCS_MSG_SETTINGS);
STR_CASE(LDCS_MSG_EXIT);
STR_CASE(LDCS_MSG_EXIT_READY);
STR_CASE(LDCS_MSG_EXIT_CANCEL);
STR_CASE(LDCS_MSG_UNKNOWN);
}
return "unknown";
}
void fmt_class_string<CellSearchError>::format(std::string& out, u64 arg)
{
format_enum(out, arg, [](auto error)
{
switch (error)
{
STR_CASE(CELL_SEARCH_CANCELED);
STR_CASE(CELL_SEARCH_ERROR_PARAM);
STR_CASE(CELL_SEARCH_ERROR_BUSY);
STR_CASE(CELL_SEARCH_ERROR_NO_MEMORY);
STR_CASE(CELL_SEARCH_ERROR_UNKNOWN_MODE);
STR_CASE(CELL_SEARCH_ERROR_ALREADY_INITIALIZED);
STR_CASE(CELL_SEARCH_ERROR_NOT_INITIALIZED);
STR_CASE(CELL_SEARCH_ERROR_FINALIZING);
STR_CASE(CELL_SEARCH_ERROR_NOT_SUPPORTED_SEARCH);
STR_CASE(CELL_SEARCH_ERROR_CONTENT_OBSOLETE);
STR_CASE(CELL_SEARCH_ERROR_CONTENT_NOT_FOUND);
STR_CASE(CELL_SEARCH_ERROR_NOT_LIST);
STR_CASE(CELL_SEARCH_ERROR_OUT_OF_RANGE);
STR_CASE(CELL_SEARCH_ERROR_INVALID_SEARCHID);
STR_CASE(CELL_SEARCH_ERROR_ALREADY_GOT_RESULT);
STR_CASE(CELL_SEARCH_ERROR_NOT_SUPPORTED_CONTEXT);
STR_CASE(CELL_SEARCH_ERROR_INVALID_CONTENTTYPE);
STR_CASE(CELL_SEARCH_ERROR_DRM);
STR_CASE(CELL_SEARCH_ERROR_TAG);
STR_CASE(CELL_SEARCH_ERROR_GENERIC);
}
return unknown;
});
}
