mirrors/Atmosphere
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere.git synced 2025-05-31 23:08:22 -04:00
Code Issues Projects Releases Packages Wiki Activity

abort/error: print backtrace, abuse templates, overhaul result/diag (macos not done yet)

Browse source
This commit is contained in:
Michael Scire 2022-03-10 01:15:45 -08:00 • committed by SciresM
parent 18168d54c3
commit 646f84bad1
118 changed files with 2843 additions and 369 deletions
Download patch file Download diff file Expand all files Collapse all files

87
libraries/libvapours/include/vapours/assert.hpp
View file

@ -16,48 +16,103 @@
#pragma once
#include <vapours/common.hpp>
namespace ams {
class Result;
namespace os {
struct UserExceptionInfo;
}
namespace impl {
NORETURN void UnexpectedDefaultImpl(const char *func, const char *file, int line);
}
}
namespace ams::diag {
NORETURN void AssertionFailureImpl(const char *file, int line, const char *func, const char *expr, u64 value, const char *format, ...) __attribute__((format(printf, 6, 7)));
NORETURN void AssertionFailureImpl(const char *file, int line, const char *func, const char *expr, u64 value);
enum AssertionType {
AssertionType_Audit,
AssertionType_Assert,
};
NORETURN void AbortImpl(const char *file, int line, const char *func, const char *expr, u64 value, const char *format, ...) __attribute__((format(printf, 6, 7)));
NORETURN void AbortImpl(const char *file, int line, const char *func, const char *expr, u64 value);
NORETURN void AbortImpl();
struct LogMessage;
struct AssertionInfo {
AssertionType type;
const LogMessage *message;
const char *expr;
const char *func;
const char *file;
int line;
};
enum AbortReason {
AbortReason_Audit,
AbortReason_Assert,
AbortReason_Abort,
AbortReason_UnexpectedDefault,
};
struct AbortInfo {
AbortReason reason;
const LogMessage *message;
const char *expr;
const char *func;
const char *file;
int line;
};
void OnAssertionFailure(AssertionType type, const char *expr, const char *func, const char *file, int line, const char *format, ...) __attribute__((format(printf, 6, 7)));
void OnAssertionFailure(AssertionType type, const char *expr, const char *func, const char *file, int line);
NORETURN void AbortImpl(const char *expr, const char *func, const char *file, int line);
NORETURN void AbortImpl(const char *expr, const char *func, const char *file, int line, const char *format, ...) __attribute__((format(printf, 5, 6)));
NORETURN void AbortImpl(const char *expr, const char *func, const char *file, int line, const ::ams::Result *result, const char *format, ...) __attribute__((format(printf, 6, 7)));
NORETURN void AbortImpl(const char *expr, const char *func, const char *file, int line, const ::ams::Result *result, const ::ams::os::UserExceptionInfo *exception_info, const char *fmt, ...) __attribute__((format(printf, 7, 8)));
NORETURN void VAbortImpl(const char *expr, const char *func, const char *file, int line, const ::ams::Result *result, const ::ams::os::UserExceptionInfo *exception_info, const char *fmt, std::va_list vl);
}
#ifdef AMS_ENABLE_DETAILED_ASSERTIONS
#define AMS_CALL_ASSERT_FAIL_IMPL(cond, ...) ::ams::diag::AssertionFailureImpl(__FILE__, __LINE__, __PRETTY_FUNCTION__, cond, 0, ## __VA_ARGS__)
#define AMS_CALL_ABORT_IMPL(cond, ...) ::ams::diag::AbortImpl(__FILE__, __LINE__, __PRETTY_FUNCTION__, cond, 0, ## __VA_ARGS__)
#define AMS_CALL_ASSERT_FAIL_IMPL(type, expr, ...) ::ams::diag::OnAssertionFailure(type, expr, __PRETTY_FUNCTION__, __FILE__, __LINE__, ## __VA_ARGS__)
#define AMS_CALL_ABORT_IMPL(expr, ...) ::ams::diag::AbortImpl(expr, __PRETTY_FUNCTION__, __FILE__, __LINE__, ## __VA_ARGS__)
#define AMS_UNREACHABLE_DEFAULT_CASE() default: ::ams::impl::UnexpectedDefaultImpl(__PRETTY_FUNCTION__, __FILE__, __LINE__)
#else
#define AMS_CALL_ASSERT_FAIL_IMPL(cond, ...) ::ams::diag::AssertionFailureImpl("", 0, "", "", 0)
#define AMS_CALL_ABORT_IMPL(cond, ...) ::ams::diag::AbortImpl(); AMS_UNUSED(cond, ## __VA_ARGS__)
#define AMS_CALL_ASSERT_FAIL_IMPL(type, expr, ...) ::ams::diag::OnAssertionFailure(type, "", "", "", 0)
#define AMS_CALL_ABORT_IMPL(expr, ...) ::ams::diag::AbortImpl("", "", "", 0); AMS_UNUSED(expr, ## __VA_ARGS__)
#define AMS_UNREACHABLE_DEFAULT_CASE() default: ::ams::impl::UnexpectedDefaultImpl("", "", 0)
#endif
#ifdef AMS_ENABLE_ASSERTIONS
#define AMS_ASSERT_IMPL(expr, ...) \
#define AMS_ASSERT_IMPL(type, expr, ...) \
{ \
if (std::is_constant_evaluated()) { \
AMS_ASSUME(static_cast<bool>(expr)); \
} else { \
if (const bool __tmp_ams_assert_val = static_cast<bool>(expr); (!__tmp_ams_assert_val)) { \
AMS_CALL_ASSERT_FAIL_IMPL(#expr, ## __VA_ARGS__); \
AMS_CALL_ASSERT_FAIL_IMPL(type, #expr, ## __VA_ARGS__); \
} \
} \
}
#elif defined(AMS_PRESERVE_ASSERTION_EXPRESSIONS)
#define AMS_ASSERT_IMPL(expr, ...) AMS_UNUSED(expr, ## __VA_ARGS__)
#define AMS_ASSERT_IMPL(type, expr, ...) AMS_UNUSED(expr, ## __VA_ARGS__)
#else
#define AMS_ASSERT_IMPL(expr, ...) static_cast<void>(0)
#define AMS_ASSERT_IMPL(type, expr, ...) static_cast<void>(0)
#endif
#define AMS_ASSERT(expr, ...) AMS_ASSERT_IMPL(expr, ## __VA_ARGS__)
#define AMS_ASSERT(expr, ...) AMS_ASSERT_IMPL(::ams::diag::AssertionType_Assert, expr, ## __VA_ARGS__)
#define AMS_UNREACHABLE_DEFAULT_CASE() default: AMS_CALL_ABORT_IMPL("Unreachable default case entered")
#ifdef AMS_BUILD_FOR_AUDITING
#define AMS_AUDIT(expr, ...) AMS_ASSERT(expr, ## __VA_ARGS__)
#define AMS_AUDIT(expr, ...) AMS_ASSERT_IMPL(::ams::diag::AssertionType_Audit, expr, ## __VA_ARGS__)
#elif defined(AMS_PRESERVE_AUDIT_EXPRESSIONS)
#define AMS_AUDIT(expr, ...) AMS_UNUSED(expr, ## __VA_ARGS__)
#else

5
libraries/libvapours/include/vapours/results/cal_results.hpp
View file

@ -16,11 +16,10 @@
#pragma once
#include <vapours/results/results_common.hpp>
#include <vapours/results/powctl_results.hpp>
namespace ams::cal {
R_DEFINE_NAMESPACE_RESULT_MODULE(198);
R_DEFINE_ERROR_RESULT(CalibrationDataCrcError, 101);
using powctl::ResultCalibrationDataCrcError;
}

5
libraries/libvapours/include/vapours/results/capsrv_results.hpp
View file

@ -16,9 +16,10 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::capsrv {
R_DEFINE_NAMESPACE_RESULT_MODULE(206);
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::capsrv, 206);
namespace ams::capsrv {
R_DEFINE_ERROR_RANGE(AlbumError, 2, 99);
R_DEFINE_ERROR_RESULT(AlbumWorkMemoryError, 3);

4
libraries/libvapours/include/vapours/results/creport_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::creport {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::creport, 168);
R_DEFINE_NAMESPACE_RESULT_MODULE(168);
namespace ams::creport {
R_DEFINE_ERROR_RESULT(UndefinedInstruction, 0);
R_DEFINE_ERROR_RESULT(InstructionAbort, 1);

4
libraries/libvapours/include/vapours/results/cs_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::cs {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::cs, 204);
R_DEFINE_NAMESPACE_RESULT_MODULE(204);
namespace ams::cs {
R_DEFINE_ERROR_RESULT(UnknownCommand, 2);
R_DEFINE_ERROR_RESULT(OutOfResource, 4);

4
libraries/libvapours/include/vapours/results/dd_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::dd {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::dd, 6);
R_DEFINE_NAMESPACE_RESULT_MODULE(6);
namespace ams::dd {
R_DEFINE_ERROR_RESULT(EndOfQuery, 1);
R_DEFINE_ERROR_RESULT(InvalidCurrentMemory, 2);

4
libraries/libvapours/include/vapours/results/ddsf_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::ddsf {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::ddsf, 30);
R_DEFINE_NAMESPACE_RESULT_MODULE(30);
namespace ams::ddsf {
R_DEFINE_ERROR_RESULT(OutOfResource, 1);
R_DEFINE_ERROR_RESULT(NotSupported, 2);

4
libraries/libvapours/include/vapours/results/debug_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::dbg {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::dbg, 183);
R_DEFINE_NAMESPACE_RESULT_MODULE(183);
namespace ams::dbg {
R_DEFINE_ERROR_RESULT(CannotDebug, 1);
R_DEFINE_ERROR_RESULT(AlreadyAttached, 2);

38
libraries/libvapours/include/vapours/results/dmnt_results.hpp
View file

@ -17,34 +17,34 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::dmnt {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::dmnt, 13);
R_DEFINE_NAMESPACE_RESULT_MODULE(13);
namespace ams::dmnt {
R_DEFINE_ERROR_RESULT(Unknown, 1);
R_DEFINE_ERROR_RESULT(DebuggingDisabled, 2);
/* Atmosphere extension. */
namespace cheat {
// namespace cheat {
R_DEFINE_ABSTRACT_ERROR_RANGE(CheatError, 6500, 6599);
R_DEFINE_ERROR_RESULT(CheatNotAttached, 6500);
R_DEFINE_ERROR_RESULT(CheatNullBuffer, 6501);
R_DEFINE_ERROR_RESULT(CheatInvalidBuffer, 6502);
R_DEFINE_ERROR_RESULT(CheatUnknownId, 6503);
R_DEFINE_ERROR_RESULT(CheatOutOfResource, 6504);
R_DEFINE_ERROR_RESULT(CheatInvalid, 6505);
R_DEFINE_ERROR_RESULT(CheatCannotDisable, 6506);
R_DEFINE_ABSTRACT_ERROR_RANGE_NS(cheat, CheatError, 6500, 6599);
R_DEFINE_ERROR_RESULT_NS(cheat, CheatNotAttached, 6500);
R_DEFINE_ERROR_RESULT_NS(cheat, CheatNullBuffer, 6501);
R_DEFINE_ERROR_RESULT_NS(cheat, CheatInvalidBuffer, 6502);
R_DEFINE_ERROR_RESULT_NS(cheat, CheatUnknownId, 6503);
R_DEFINE_ERROR_RESULT_NS(cheat, CheatOutOfResource, 6504);
R_DEFINE_ERROR_RESULT_NS(cheat, CheatInvalid, 6505);
R_DEFINE_ERROR_RESULT_NS(cheat, CheatCannotDisable, 6506);
R_DEFINE_ABSTRACT_ERROR_RANGE(FrozenAddressError, 6600, 6699);
R_DEFINE_ERROR_RESULT(FrozenAddressInvalidWidth, 6600);
R_DEFINE_ERROR_RESULT(FrozenAddressAlreadyExists, 6601);
R_DEFINE_ERROR_RESULT(FrozenAddressNotFound, 6602);
R_DEFINE_ERROR_RESULT(FrozenAddressOutOfResource, 6603);
R_DEFINE_ABSTRACT_ERROR_RANGE_NS(cheat, FrozenAddressError, 6600, 6699);
R_DEFINE_ERROR_RESULT_NS(cheat, FrozenAddressInvalidWidth, 6600);
R_DEFINE_ERROR_RESULT_NS(cheat, FrozenAddressAlreadyExists, 6601);
R_DEFINE_ERROR_RESULT_NS(cheat, FrozenAddressNotFound, 6602);
R_DEFINE_ERROR_RESULT_NS(cheat, FrozenAddressOutOfResource, 6603);
R_DEFINE_ABSTRACT_ERROR_RANGE(VirtualMachineError, 6700, 6799);
R_DEFINE_ERROR_RESULT(VirtualMachineInvalidConditionDepth, 6700);
R_DEFINE_ABSTRACT_ERROR_RANGE_NS(cheat, VirtualMachineError, 6700, 6799);
R_DEFINE_ERROR_RESULT_NS(cheat, VirtualMachineInvalidConditionDepth, 6700);
}
// }
}

4
libraries/libvapours/include/vapours/results/erpt_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::erpt {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::erpt, 147);
R_DEFINE_NAMESPACE_RESULT_MODULE(147);
namespace ams::erpt {
R_DEFINE_ERROR_RESULT(NotInitialized, 1);
R_DEFINE_ERROR_RESULT(AlreadyInitialized, 2);

4
libraries/libvapours/include/vapours/results/err_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::err {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::err, 162);
R_DEFINE_NAMESPACE_RESULT_MODULE(162);
namespace ams::err {
R_DEFINE_ERROR_RESULT(ApplicationAbort, 1);
R_DEFINE_ERROR_RESULT(SystemProgramAbort, 2);

7
libraries/libvapours/include/vapours/results/exosphere_results.hpp
View file

@ -17,12 +17,11 @@
#pragma once
#include <vapours/results/results_common.hpp>
/* Please note: These results are all custom, and not official. */
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::exosphere, 444);
namespace ams::exosphere {
/* Please note: These results are all custom, and not official. */
R_DEFINE_NAMESPACE_RESULT_MODULE(444);
/* Result 1-1000 reserved for Atmosphere. */
R_DEFINE_ERROR_RESULT(NotPresent, 1);
R_DEFINE_ERROR_RESULT(VersionMismatch, 2);

4
libraries/libvapours/include/vapours/results/fatal_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::fatal {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::fatal, 163);
R_DEFINE_NAMESPACE_RESULT_MODULE(163);
namespace ams::fatal {
R_DEFINE_ERROR_RESULT(AllocationFailed, 1);
R_DEFINE_ERROR_RESULT(NullGraphicsBuffer, 2);

6
libraries/libvapours/include/vapours/results/fs_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::fs {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::fs, 2);
R_DEFINE_NAMESPACE_RESULT_MODULE(2);
namespace ams::fs {
R_DEFINE_ERROR_RANGE(HandledByAllProcess, 0, 999);
R_DEFINE_ERROR_RESULT(PathNotFound, 1);
@ -217,7 +217,7 @@ namespace ams::fs {
R_DEFINE_ERROR_RESULT(NcaBaseStorageOutOfRangeC, 4510);
R_DEFINE_ERROR_RESULT(NcaBaseStorageOutOfRangeD, 4511);
R_DEFINE_ERROR_RANGE(NcaFileSystemCorrupted, 4512, 4529);
R_DEFINE_ERROR_RESULT_CLASS_IMPL(NcaFileSystemCorrupted, 4512, 4529);
R_DEFINE_ERROR_RESULT(InvalidNcaFileSystemType, 4512);
R_DEFINE_ERROR_RESULT(InvalidAcidFileSize, 4513);
R_DEFINE_ERROR_RESULT(InvalidAcidSize, 4514);

4
libraries/libvapours/include/vapours/results/gpio_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::gpio {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::gpio, 102);
R_DEFINE_NAMESPACE_RESULT_MODULE(102);
namespace ams::gpio {
R_DEFINE_ERROR_RESULT(AlreadyBound, 1);
R_DEFINE_ERROR_RESULT(AlreadyOpen, 2);

4
libraries/libvapours/include/vapours/results/hipc_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::sf::hipc {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::sf::hipc, 11);
R_DEFINE_NAMESPACE_RESULT_MODULE(11);
namespace ams::sf::hipc {
R_DEFINE_ABSTRACT_ERROR_RANGE(OutOfResource, 100, 299);
R_DEFINE_ERROR_RESULT(OutOfSessionMemory, 102);

4
libraries/libvapours/include/vapours/results/htc_results.hpp
View file

@ -16,9 +16,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::htc {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::htc, 18);
R_DEFINE_NAMESPACE_RESULT_MODULE(18);
namespace ams::htc {
R_DEFINE_ERROR_RESULT(ConnectionFailure, 1);
R_DEFINE_ERROR_RESULT(NotFound, 2);

4
libraries/libvapours/include/vapours/results/htcfs_results.hpp
View file

@ -16,9 +16,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::htcfs {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::htcfs, 31);
R_DEFINE_NAMESPACE_RESULT_MODULE(31);
namespace ams::htcfs {
R_DEFINE_ERROR_RESULT(InvalidArgument, 3);

6
libraries/libvapours/include/vapours/results/htclow_results.hpp
View file

@ -16,9 +16,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::htclow {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::htclow, 29);
R_DEFINE_NAMESPACE_RESULT_MODULE(29);
namespace ams::htclow {
R_DEFINE_ERROR_RESULT(ConnectionFailure, 1);
R_DEFINE_ERROR_RESULT(UnknownDriverType, 3);
@ -28,7 +28,7 @@ namespace ams::htclow {
R_DEFINE_ERROR_RESULT(ChannelNotExist, 10);
R_DEFINE_ERROR_RESULT(OutOfChannel, 151);
R_DEFINE_ERROR_RESULT(OutOfTask, 151);
R_DEFINE_ERROR_RESULT(OutOfTask, 152);
R_DEFINE_ERROR_RESULT(InvalidChannelState, 200);
R_DEFINE_ERROR_RESULT(InvalidChannelStateDisconnected, 201);

4
libraries/libvapours/include/vapours/results/htcs_results.hpp
View file

@ -16,9 +16,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::htcs {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::htcs, 4);
R_DEFINE_NAMESPACE_RESULT_MODULE(4);
namespace ams::htcs {
R_DEFINE_ERROR_RESULT(InvalidHandle, 9);

4
libraries/libvapours/include/vapours/results/i2c_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::i2c {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::i2c, 101);
R_DEFINE_NAMESPACE_RESULT_MODULE(101);
namespace ams::i2c {
R_DEFINE_ERROR_RESULT(NoAck, 1);
R_DEFINE_ERROR_RESULT(BusBusy, 2);

4
libraries/libvapours/include/vapours/results/kvdb_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::kvdb {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::kvdb, 20);
R_DEFINE_NAMESPACE_RESULT_MODULE(20);
namespace ams::kvdb {
R_DEFINE_ERROR_RESULT(OutOfKeyResource, 1);
R_DEFINE_ERROR_RESULT(KeyNotFound, 2);

4
libraries/libvapours/include/vapours/results/loader_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::ldr {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::ldr, 9);
R_DEFINE_NAMESPACE_RESULT_MODULE(9);
namespace ams::ldr {
R_DEFINE_ERROR_RESULT(ArgumentOverflow, 1);
R_DEFINE_ERROR_RESULT(ArgumentCountOverflow, 2);

4
libraries/libvapours/include/vapours/results/lr_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::lr {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::lr, 8);
R_DEFINE_NAMESPACE_RESULT_MODULE(8);
namespace ams::lr {
R_DEFINE_ERROR_RESULT(ProgramNotFound, 2);
R_DEFINE_ERROR_RESULT(DataNotFound, 3);

4
libraries/libvapours/include/vapours/results/ncm_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::ncm {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::ncm, 5);
R_DEFINE_NAMESPACE_RESULT_MODULE(5);
namespace ams::ncm {
R_DEFINE_ERROR_RESULT(InvalidContentStorageBase, 1);
R_DEFINE_ERROR_RESULT(PlaceHolderAlreadyExists, 2);

4
libraries/libvapours/include/vapours/results/nim_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::nim {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::nim, 137);
R_DEFINE_NAMESPACE_RESULT_MODULE(137);
namespace ams::nim {
R_DEFINE_ERROR_RESULT(HttpConnectionCanceled, 70);

4
libraries/libvapours/include/vapours/results/ns_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::ns {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::ns, 16);
R_DEFINE_NAMESPACE_RESULT_MODULE(16);
namespace ams::ns {
R_DEFINE_ERROR_RESULT(Canceled, 90);
R_DEFINE_ERROR_RESULT(OutOfMaxRunningTask, 110);

4
libraries/libvapours/include/vapours/results/os_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::os {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::os, 3);
R_DEFINE_NAMESPACE_RESULT_MODULE(3);
namespace ams::os {
R_DEFINE_ERROR_RESULT(Busy, 4);

4
libraries/libvapours/include/vapours/results/osdbg_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::osdbg {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::osdbg, 7);
R_DEFINE_NAMESPACE_RESULT_MODULE(7);
namespace ams::osdbg {
R_DEFINE_ERROR_RESULT(CannotGetThreadInfo, 1);
R_DEFINE_ERROR_RESULT(UnsupportedThreadVersion, 2);

4
libraries/libvapours/include/vapours/results/pcv_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::pcv {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::pcv, 133);
R_DEFINE_NAMESPACE_RESULT_MODULE(133);
namespace ams::pcv {
R_DEFINE_ERROR_RESULT(IllegalRequest, 16);

4
libraries/libvapours/include/vapours/results/pgl_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::pgl {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::pgl, 228);
R_DEFINE_NAMESPACE_RESULT_MODULE(228);
namespace ams::pgl {
R_DEFINE_ERROR_RESULT(NotImplemented, 1);
R_DEFINE_ERROR_RESULT(NotAvailable, 2);

4
libraries/libvapours/include/vapours/results/pm_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::pm {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::pm, 15);
R_DEFINE_NAMESPACE_RESULT_MODULE(15);
namespace ams::pm {
R_DEFINE_ERROR_RESULT(ProcessNotFound, 1);
R_DEFINE_ERROR_RESULT(AlreadyStarted, 2);

6
libraries/libvapours/include/vapours/results/powctl_results.hpp
View file

@ -17,12 +17,14 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::powctl {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::powctl, 198);
R_DEFINE_NAMESPACE_RESULT_MODULE(198);
namespace ams::powctl {
R_DEFINE_ERROR_RESULT(NotSupported, 1);
R_DEFINE_ERROR_RESULT(InvalidArgument, 2);
R_DEFINE_ERROR_RESULT(NotAvailable, 3);
R_DEFINE_ERROR_RESULT(CalibrationDataCrcError, 101);
}

4
libraries/libvapours/include/vapours/results/psc_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::psc {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::psc, 138);
R_DEFINE_NAMESPACE_RESULT_MODULE(138);
namespace ams::psc {
R_DEFINE_ERROR_RESULT(AlreadyInitialized, 2);
R_DEFINE_ERROR_RESULT(NotInitialized, 3);

4
libraries/libvapours/include/vapours/results/pwm_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::pwm {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::pwm, 189);
R_DEFINE_NAMESPACE_RESULT_MODULE(189);
namespace ams::pwm {
R_DEFINE_ERROR_RESULT(InvalidArgument, 2);

91
libraries/libvapours/include/vapours/results/results_common.hpp
View file

@ -20,8 +20,25 @@
namespace ams {
const char *GetResultName(int module, int description);
namespace result::impl {
#if defined(AMS_AUTO_GENERATE_RESULT_NAMES)
struct DummyNameHolder {
static constexpr bool Exists = false;
static constexpr const char *Name = "unknown";
};
template<int Module>
struct ResultNameSpaceExistsImpl {
static constexpr bool Exists = false;
template<int Description>
using NameHolder = DummyNameHolder;
};
#endif
class ResultTraits {
public:
using BaseType = u32;
@ -113,6 +130,10 @@ namespace ams {
static_assert(sizeof(Result) == sizeof(Result::Base::BaseType), "sizeof(Result) == sizeof(Result::Base::BaseType)");
static_assert(std::is_trivially_destructible<Result>::value, "std::is_trivially_destructible<Result>::value");
ALWAYS_INLINE const char *GetResultName(const Result &result) {
return GetResultName(result.GetModule(), result.GetDescription());
}
namespace result::impl {
class ResultInternalAccessor {
@ -230,25 +251,75 @@ namespace ams {
}
/* Macros for defining new results. */
#define R_DEFINE_NAMESPACE_RESULT_MODULE(value) namespace impl::result { static constexpr inline ::ams::result::impl::ResultTraits::BaseType ResultModuleId = value; }
#define R_CURRENT_NAMESPACE_RESULT_MODULE impl::result::ResultModuleId
#if defined(AMS_AUTO_GENERATE_RESULT_NAMES)
#define R_DEFINE_NAMESPACE_RESULT_MODULE(nmspc, value) \
namespace nmspc { \
\
namespace result_impl { \
static constexpr inline ::ams::result::impl::ResultTraits::BaseType ResultModuleId = value; \
\
template<int Description> \
struct ResultNameHolderImpl { static constexpr bool Exists = false; }; \
} \
\
} \
\
namespace ams::result::impl { \
\
template<> struct ResultNameSpaceExistsImpl<value> { \
static constexpr bool Exists = true; \
\
template<int Description> \
using NameHolder = nmspc::result_impl::ResultNameHolderImpl<Description>; \
}; \
\
}
#else
#define R_DEFINE_NAMESPACE_RESULT_MODULE(nmspc, value) \
namespace nmspc { \
\
namespace result_impl { \
static constexpr inline ::ams::result::impl::ResultTraits::BaseType ResultModuleId = value; \
} \
\
}
#endif
#define R_CURRENT_NAMESPACE_RESULT_MODULE result_impl::ResultModuleId
#define R_NAMESPACE_MODULE_ID(nmspc) nmspc::R_CURRENT_NAMESPACE_RESULT_MODULE
#define R_MAKE_NAMESPACE_RESULT(nmspc, desc) static_cast<::ams::Result>(::ams::result::impl::ResultTraits::MakeValue(R_NAMESPACE_MODULE_ID(nmspc), desc))
#define R_DEFINE_ERROR_RESULT_IMPL(name, desc_start, desc_end) \
#if defined(AMS_AUTO_GENERATE_RESULT_NAMES)
#define R_DEFINE_ERROR_RESULT_NAME_HOLDER_IMPL(name, desc_start, desc_end) \
template<> struct result_impl::ResultNameHolderImpl<desc_start> { static constexpr bool Exists = true; static constexpr const char *Name = #name; };
#else
#define R_DEFINE_ERROR_RESULT_NAME_HOLDER_IMPL(name, desc_start, desc_end)
#endif
#define R_DEFINE_ERROR_RESULT_CLASS_IMPL(name, desc_start, desc_end) \
class Result##name final : public ::ams::result::impl::ResultErrorBase<R_CURRENT_NAMESPACE_RESULT_MODULE, desc_start>, public ::ams::result::impl::ResultErrorRangeBase<R_CURRENT_NAMESPACE_RESULT_MODULE, desc_start, desc_end> {}
#define R_DEFINE_ERROR_RESULT_IMPL(name, desc_start, desc_end) \
R_DEFINE_ERROR_RESULT_NAME_HOLDER_IMPL(name, desc_start, desc_end) \
R_DEFINE_ERROR_RESULT_CLASS_IMPL(name, desc_start, desc_end)
#define R_DEFINE_ABSTRACT_ERROR_RESULT_IMPL(name, desc_start, desc_end) \
class Result##name final : public ::ams::result::impl::ResultErrorRangeBase<R_CURRENT_NAMESPACE_RESULT_MODULE, desc_start, desc_end> {}
#define R_DEFINE_ERROR_RESULT(name, desc) R_DEFINE_ERROR_RESULT_IMPL(name, desc, desc)
#define R_DEFINE_ERROR_RANGE(name, start, end) R_DEFINE_ERROR_RESULT_IMPL(name, start, end)
#define R_DEFINE_ABSTRACT_ERROR_RESULT(name, desc) R_DEFINE_ABSTRACT_ERROR_RESULT_IMPL(name, desc, desc)
#define R_DEFINE_ABSTRACT_ERROR_RANGE(name, start, end) R_DEFINE_ABSTRACT_ERROR_RESULT_IMPL(name, start, end)
#define R_DEFINE_ERROR_RESULT_NS(ns, name, desc) namespace ns { R_DEFINE_ERROR_RESULT_CLASS_IMPL(name, desc, desc); } R_DEFINE_ERROR_RESULT_NAME_HOLDER_IMPL(name, desc, desc)
#define R_DEFINE_ERROR_RANGE_NS(ns, name, start, end) namespace ns { R_DEFINE_ERROR_RESULT_CLASS_IMPL(name, start, end); } R_DEFINE_ERROR_RESULT_NAME_HOLDER_IMPL(name, start, end)
#define R_DEFINE_ABSTRACT_ERROR_RESULT_NS(ns, name, desc) namespace ns { R_DEFINE_ABSTRACT_ERROR_RESULT_IMPL(name, desc, desc); }
#define R_DEFINE_ABSTRACT_ERROR_RANGE_NS(ns, name, start, end) namespace ns { R_DEFINE_ABSTRACT_ERROR_RESULT_IMPL(name, start, end); }
/* Remove libnx macros, replace with our own. */
#ifndef R_SUCCEEDED
#error "R_SUCCEEDED not defined."
@ -384,14 +455,12 @@ namespace ams::result::impl {
#if defined(ATMOSPHERE_BOARD_NINTENDO_NX) && defined(ATMOSPHERE_IS_STRATOSPHERE) && !defined(AMS_ENABLE_DETAILED_ASSERTIONS) && !defined(AMS_BUILD_FOR_DEBUGGING) && !defined(AMS_BUILD_FOR_AUDITING)
#define AMS_CALL_ON_RESULT_ASSERTION_IMPL(cond, val) do { ::ams::diag::impl::FatalErrorByResultForNx(val); AMS_INFINITE_LOOP(); AMS_ASSUME(false); } while (false)
#define AMS_CALL_ON_RESULT_ABORT_IMPL(cond, val) do { ::ams::diag::impl::FatalErrorByResultForNx(val); AMS_INFINITE_LOOP(); AMS_ASSUME(false); } while (false)
#elif defined(ATMOSPHERE_OS_HORIZON)
#define AMS_CALL_ON_RESULT_ASSERTION_IMPL(cond, val) AMS_CALL_ASSERT_FAIL_IMPL(::ams::diag::AssertionType_Assert, "ams::Result::IsSuccess()", "Failed: %s\n Module: %d\n Description: %d\n InnerValue: 0x%08" PRIX32, cond, val.GetModule(), val.GetDescription(), static_cast<::ams::Result>(val).GetInnerValue())
#define AMS_CALL_ON_RESULT_ABORT_IMPL(cond, val) AMS_CALL_ABORT_IMPL("ams::Result::IsSuccess()", "Failed: %s\n Module: %d\n Description: %d\n InnerValue: 0x%08" PRIX32, cond, val.GetModule(), val.GetDescription(), static_cast<::ams::Result>(val).GetInnerValue())
#else
#if defined(AMS_ENABLE_DETAILED_ASSERTIONS)
#define AMS_CALL_ON_RESULT_ASSERTION_IMPL(cond, val) ::ams::result::impl::OnResultAssertion(__FILE__, __LINE__, __PRETTY_FUNCTION__, cond, val)
#define AMS_CALL_ON_RESULT_ABORT_IMPL(cond, val) ::ams::result::impl::OnResultAbort(__FILE__, __LINE__, __PRETTY_FUNCTION__, cond, val)
#else
#define AMS_CALL_ON_RESULT_ASSERTION_IMPL(cond, val) ::ams::result::impl::OnResultAssertion("", 0, "", "", val)
#define AMS_CALL_ON_RESULT_ABORT_IMPL(cond, val) ::ams::result::impl::OnResultAbort("", 0, "", "", val)
#endif
#define AMS_CALL_ON_RESULT_ASSERTION_IMPL(cond, val) AMS_CALL_ASSERT_FAIL_IMPL(::ams::diag::AssertionType_Assert, "ams::Result::IsSuccess()", "Failed: %s\n Module: %d\n Description: %d\n InnerValue: 0x%08" PRIX32 "\n Name: %s", cond, val.GetModule(), val.GetDescription(), static_cast<::ams::Result>(val).GetInnerValue(), ::ams::GetResultName(val))
#define AMS_CALL_ON_RESULT_ABORT_IMPL(cond, val) AMS_CALL_ABORT_IMPL("ams::Result::IsSuccess()", "Failed: %s\n Module: %d\n Description: %d\n InnerValue: 0x%08" PRIX32 "\n Name: %s", cond, val.GetModule(), val.GetDescription(), static_cast<::ams::Result>(val).GetInnerValue(), ::ams::GetResultName(val))
#endif
/// Evaluates an expression that returns a result, and asserts the result if it would fail.

4
libraries/libvapours/include/vapours/results/ro_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::ro {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::ro, 22);
R_DEFINE_NAMESPACE_RESULT_MODULE(22);
namespace ams::ro {
R_DEFINE_ERROR_RANGE(RoError, 1, 1023);
R_DEFINE_ERROR_RESULT(OutOfAddressSpace, 2);

9
libraries/libvapours/include/vapours/results/scs_results.hpp
View file

@ -16,13 +16,12 @@
#pragma once
#include <vapours/results/results_common.hpp>
#include <vapours/results/cs_results.hpp>
namespace ams::scs {
R_DEFINE_NAMESPACE_RESULT_MODULE(204);
R_DEFINE_ERROR_RESULT(UnknownCommand, 2);
R_DEFINE_ERROR_RESULT(OutOfResource, 4);
R_DEFINE_ERROR_RESULT(NoSocket, 7);
using ams::cs::ResultUnknownCommand;
using ams::cs::ResultOutOfResource;
using ams::cs::ResultNoSocket;
}

4
libraries/libvapours/include/vapours/results/sdmmc_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::sdmmc {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::sdmmc, 24);
R_DEFINE_NAMESPACE_RESULT_MODULE(24);
namespace ams::sdmmc {
R_DEFINE_ERROR_RESULT(NoDevice, 1);
R_DEFINE_ERROR_RESULT(NotActivated, 2);

4
libraries/libvapours/include/vapours/results/settings_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::settings {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::settings, 105);
R_DEFINE_NAMESPACE_RESULT_MODULE(105);
namespace ams::settings {
R_DEFINE_ERROR_RESULT(SettingsItemNotFound, 11);
R_DEFINE_ERROR_RESULT(StopIteration, 21);

36
libraries/libvapours/include/vapours/results/sf_results.hpp
View file

@ -17,36 +17,36 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::sf {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::sf, 10);
R_DEFINE_NAMESPACE_RESULT_MODULE(10);
namespace ams::sf {
R_DEFINE_ERROR_RESULT(NotSupported, 1);
R_DEFINE_ERROR_RESULT(PreconditionViolation, 3);
namespace cmif {
//namespace cmif {
R_DEFINE_ERROR_RESULT(InvalidHeaderSize, 202);
R_DEFINE_ERROR_RESULT(InvalidInHeader, 211);
R_DEFINE_ERROR_RESULT(UnknownCommandId, 221);
R_DEFINE_ERROR_RESULT(InvalidOutRawSize, 232);
R_DEFINE_ERROR_RESULT(InvalidNumInObjects, 235);
R_DEFINE_ERROR_RESULT(InvalidNumOutObjects, 236);
R_DEFINE_ERROR_RESULT(InvalidInObject, 239);
R_DEFINE_ERROR_RESULT_NS(cmif, InvalidHeaderSize, 202);
R_DEFINE_ERROR_RESULT_NS(cmif, InvalidInHeader, 211);
R_DEFINE_ERROR_RESULT_NS(cmif, UnknownCommandId, 221);
R_DEFINE_ERROR_RESULT_NS(cmif, InvalidOutRawSize, 232);
R_DEFINE_ERROR_RESULT_NS(cmif, InvalidNumInObjects, 235);
R_DEFINE_ERROR_RESULT_NS(cmif, InvalidNumOutObjects, 236);
R_DEFINE_ERROR_RESULT_NS(cmif, InvalidInObject, 239);
R_DEFINE_ERROR_RESULT(TargetNotFound, 261);
R_DEFINE_ERROR_RESULT_NS(cmif, TargetNotFound, 261);
R_DEFINE_ERROR_RESULT(OutOfDomainEntries, 301);
R_DEFINE_ERROR_RESULT_NS(cmif, OutOfDomainEntries, 301);
}
//}
namespace impl {
//namespace impl {
R_DEFINE_ABSTRACT_ERROR_RANGE(RequestContextChanged, 800, 899);
R_DEFINE_ABSTRACT_ERROR_RANGE(RequestInvalidated, 801, 809);
R_DEFINE_ERROR_RESULT(RequestInvalidatedByUser, 802);
R_DEFINE_ABSTRACT_ERROR_RANGE_NS(impl, RequestContextChanged, 800, 899);
R_DEFINE_ABSTRACT_ERROR_RANGE_NS(impl, RequestInvalidated, 801, 809);
R_DEFINE_ERROR_RESULT_NS(impl, RequestInvalidatedByUser, 802);
}
//}
R_DEFINE_ABSTRACT_ERROR_RANGE(RequestDeferred, 811, 819);
R_DEFINE_ERROR_RESULT(RequestDeferredByUser, 812);

12
libraries/libvapours/include/vapours/results/sm_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::sm {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::sm, 21);
R_DEFINE_NAMESPACE_RESULT_MODULE(21);
namespace ams::sm {
R_DEFINE_ERROR_RESULT(OutOfProcesses, 1);
R_DEFINE_ERROR_RESULT(InvalidClient, 2);
@ -32,11 +32,11 @@ namespace ams::sm {
R_DEFINE_ERROR_RESULT(TooLargeAccessControl, 9);
/* Results 1000-2000 used as extension for Atmosphere Mitm. */
namespace mitm {
//namespace mitm {
R_DEFINE_ERROR_RESULT(ShouldForwardToSession, 1000);
R_DEFINE_ERROR_RESULT(ProcessNotAssociated, 1100);
R_DEFINE_ERROR_RESULT_NS(mitm, ShouldForwardToSession, 1000);
R_DEFINE_ERROR_RESULT_NS(mitm, ProcessNotAssociated, 1100);
}
//}
}

4
libraries/libvapours/include/vapours/results/socket_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::socket {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::socket, 27);
R_DEFINE_NAMESPACE_RESULT_MODULE(27);
namespace ams::socket {
R_DEFINE_ERROR_RESULT(InsufficientProvidedMemory, 1);

4
libraries/libvapours/include/vapours/results/spl_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::spl {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::spl, 26);
R_DEFINE_NAMESPACE_RESULT_MODULE(26);
namespace ams::spl {
R_DEFINE_ERROR_RANGE(SecureMonitorError, 0, 99);
R_DEFINE_ERROR_RESULT(SecureMonitorNotSupported, 1);

4
libraries/libvapours/include/vapours/results/sprofile_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::sprofile {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::sprofile, 246);
R_DEFINE_NAMESPACE_RESULT_MODULE(246);
namespace ams::sprofile {
R_DEFINE_ERROR_RESULT(InvalidArgument, 100);
R_DEFINE_ERROR_RESULT(InvalidState, 101);

4
libraries/libvapours/include/vapours/results/svc_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::svc {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::svc, 1);
R_DEFINE_NAMESPACE_RESULT_MODULE(1);
namespace ams::svc {
R_DEFINE_ERROR_RESULT(OutOfSessions, 7);

4
libraries/libvapours/include/vapours/results/time_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::time {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::time, 116);
R_DEFINE_NAMESPACE_RESULT_MODULE(116);
namespace ams::time {
R_DEFINE_ERROR_RESULT(NotInitialized, 0);

4
libraries/libvapours/include/vapours/results/tipc_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::tipc {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::tipc, 35);
R_DEFINE_NAMESPACE_RESULT_MODULE(35);
namespace ams::tipc {
R_DEFINE_ERROR_RESULT(InvalidMethod, 10);
R_DEFINE_ERROR_RESULT(InvalidMessageFormat, 15);

4
libraries/libvapours/include/vapours/results/tma_results.hpp
View file

@ -16,9 +16,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::tma {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::tma, 12);
R_DEFINE_NAMESPACE_RESULT_MODULE(12);
namespace ams::tma {
R_DEFINE_ERROR_RESULT(Unknown, 1);

4
libraries/libvapours/include/vapours/results/updater_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::updater {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::updater, 158);
R_DEFINE_NAMESPACE_RESULT_MODULE(158);
namespace ams::updater {
R_DEFINE_ERROR_RESULT(BootImagePackageNotFound, 2);
R_DEFINE_ERROR_RESULT(InvalidBootImagePackage, 3);

4
libraries/libvapours/include/vapours/results/usb_results.hpp
View file

@ -16,9 +16,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::usb {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::usb, 140);
R_DEFINE_NAMESPACE_RESULT_MODULE(140);
namespace ams::usb {
R_DEFINE_ERROR_RESULT(NotInitialized, 0);
R_DEFINE_ERROR_RESULT(AlreadyInitialized, 1);

4
libraries/libvapours/include/vapours/results/vi_results.hpp
View file

@ -17,9 +17,9 @@
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::vi {
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::vi, 114);
R_DEFINE_NAMESPACE_RESULT_MODULE(114);
namespace ams::vi {
R_DEFINE_ERROR_RESULT(OperationFailed, 1);
R_DEFINE_ERROR_RESULT(NotSupported, 6);

73
libraries/libvapours/source/result/result_get_name.cpp Normal file
View file

@ -0,0 +1,73 @@
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#if !defined(ATMOSPHERE_OS_HORIZON) && (defined(AMS_BUILD_FOR_DEBUGGING) || defined(AMS_BUILD_FOR_AUDITING))
#define AMS_AUTO_GENERATE_RESULT_NAMES
#endif
#include <vapours.hpp>
namespace ams {
#if defined(AMS_AUTO_GENERATE_RESULT_NAMES)
#define AMS_INVOKE_MACRO_01(EXPR, n) EXPR(n); EXPR(n + (1 << 0));
#define AMS_INVOKE_MACRO_02(EXPR, n) AMS_INVOKE_MACRO_01(EXPR, n); AMS_INVOKE_MACRO_01(EXPR, n + (1 << 1));
#define AMS_INVOKE_MACRO_03(EXPR, n) AMS_INVOKE_MACRO_02(EXPR, n); AMS_INVOKE_MACRO_02(EXPR, n + (1 << 2));
#define AMS_INVOKE_MACRO_04(EXPR, n) AMS_INVOKE_MACRO_03(EXPR, n); AMS_INVOKE_MACRO_03(EXPR, n + (1 << 3));
#define AMS_INVOKE_MACRO_05(EXPR, n) AMS_INVOKE_MACRO_04(EXPR, n); AMS_INVOKE_MACRO_04(EXPR, n + (1 << 4));
#define AMS_INVOKE_MACRO_06(EXPR, n) AMS_INVOKE_MACRO_05(EXPR, n); AMS_INVOKE_MACRO_05(EXPR, n + (1 << 5));
#define AMS_INVOKE_MACRO_07(EXPR, n) AMS_INVOKE_MACRO_06(EXPR, n); AMS_INVOKE_MACRO_06(EXPR, n + (1 << 6));
#define AMS_INVOKE_MACRO_08(EXPR, n) AMS_INVOKE_MACRO_07(EXPR, n); AMS_INVOKE_MACRO_07(EXPR, n + (1 << 7));
#define AMS_INVOKE_MACRO_09(EXPR, n) AMS_INVOKE_MACRO_08(EXPR, n); AMS_INVOKE_MACRO_08(EXPR, n + (1 << 8));
#define AMS_INVOKE_MACRO_10(EXPR, n) AMS_INVOKE_MACRO_09(EXPR, n); AMS_INVOKE_MACRO_09(EXPR, n + (1 << 9));
#define AMS_INVOKE_MACRO_11(EXPR, n) AMS_INVOKE_MACRO_10(EXPR, n); AMS_INVOKE_MACRO_10(EXPR, n + (1 << 10));
#define AMS_INVOKE_MACRO_12(EXPR, n) AMS_INVOKE_MACRO_11(EXPR, n); AMS_INVOKE_MACRO_11(EXPR, n + (1 << 11));
#define AMS_INVOKE_MACRO_13(EXPR, n) AMS_INVOKE_MACRO_12(EXPR, n); AMS_INVOKE_MACRO_12(EXPR, n + (1 << 12));
namespace {
template<int Module, int Description>
constexpr const char *GetResultNameByModuleAndDescription() {
return ::ams::result::impl::ResultNameSpaceExistsImpl<Module>::template NameHolder<Description>::Name;
}
template<int Module>
constexpr const char *GetResultNameByModule(int description) {
#define AMS_TEST_RESULT_DESCRIPTION_DEFINED(n) if constexpr (::ams::result::impl::ResultNameSpaceExistsImpl<Module>::template NameHolder<n>::Exists) { if (description == n) { return GetResultNameByModuleAndDescription<Module, n>(); } }
AMS_INVOKE_MACRO_13(AMS_TEST_RESULT_DESCRIPTION_DEFINED, 0)
return "Unknown";
}
}
const char *GetResultName(int module, int description) {
#define AMS_TEST_RESULT_MODULE_DEFINED(n) if constexpr (::ams::result::impl::ResultNameSpaceExistsImpl<n>::Exists) { if (module == n) { return GetResultNameByModule<n>(description); } }
AMS_INVOKE_MACRO_08(AMS_TEST_RESULT_MODULE_DEFINED, 0)
return "Unknown";
}
#else
const char *GetResultName(int, int) {
return "Unknown";
}
#endif
}

4
libraries/libvapours/source/util/util_format_string.cpp
View file

@ -394,7 +394,9 @@ namespace ams::util {
/* Ensure null termination. */
WriteCharacter('\0');
dst[dst_size - 1] = '\0';
if (dst_size > 0) {
dst[dst_size - 1] = '\0';
}
/* Return number of characters that would have been printed sans the null terminator. */
return static_cast<int>(dst_index) - 1;