Revert "hoc-clk: add live vdd2, live boost clock and basic pwm dimming"
This reverts commit 15b7df8ef1.
This commit is contained in:
souldbminersmwc
@@ -1,25 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
#include <vapours/results/powctl_results.hpp>
|
||||
|
||||
namespace ams::cal {
|
||||
|
||||
using powctl::ResultCalibrationDataCrcError;
|
||||
|
||||
}
|
||||
@@ -1,94 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::capsrv, 206);
|
||||
|
||||
namespace ams::capsrv {
|
||||
|
||||
R_DEFINE_ERROR_RANGE(AlbumError, 2, 99);
|
||||
R_DEFINE_ERROR_RESULT(AlbumWorkMemoryError, 3);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(AlbumAlreadyOpened, 7);
|
||||
R_DEFINE_ERROR_RESULT(AlbumOutOfRange, 8);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(AlbumInvalidFileId, 10, 19);
|
||||
R_DEFINE_ERROR_RESULT(AlbumInvalidApplicationId, 11);
|
||||
R_DEFINE_ERROR_RESULT(AlbumInvalidTimestamp, 12);
|
||||
R_DEFINE_ERROR_RESULT(AlbumInvalidStorage, 13);
|
||||
R_DEFINE_ERROR_RESULT(AlbumInvalidFileContents, 14);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(AlbumIsNotMounted, 21);
|
||||
R_DEFINE_ERROR_RESULT(AlbumIsFull, 22);
|
||||
R_DEFINE_ERROR_RESULT(AlbumFileNotFound, 23);
|
||||
R_DEFINE_ERROR_RESULT(AlbumInvalidFileData, 24);
|
||||
R_DEFINE_ERROR_RESULT(AlbumFileCountLimit, 25);
|
||||
R_DEFINE_ERROR_RESULT(AlbumFileNoThumbnail, 26);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(AlbumReadBufferShortage, 30);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(AlbumFileSystemError, 90, 99);
|
||||
R_DEFINE_ERROR_RANGE(AlbumAccessCorrupted, 94, 96);
|
||||
R_DEFINE_ERROR_RESULT(AlbumDestinationAccessCorrupted, 96);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(ControlError, 800, 899);
|
||||
R_DEFINE_ERROR_RESULT(ControlResourceLimit, 820);
|
||||
R_DEFINE_ERROR_RESULT(ControlNotOpened, 822);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NotSupported, 1023);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(InternalError, 1024, 2047);
|
||||
R_DEFINE_ERROR_RESULT(InternalJpegEncoderError, 1210);
|
||||
R_DEFINE_ERROR_RESULT(InternalJpegOutBufferShortage, 1211);
|
||||
R_DEFINE_ERROR_RESULT(InternalJpegWorkMemoryShortage, 1212);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(InternalFileDataVerificationError, 1300, 1399);
|
||||
R_DEFINE_ERROR_RESULT(InternalFileDataVerificationEmptyFileData, 1301);
|
||||
R_DEFINE_ERROR_RESULT(InternalFileDataVerificationExifExtractionFailed, 1302);
|
||||
R_DEFINE_ERROR_RESULT(InternalFileDataVerificationExifAnalyzationFailed, 1303);
|
||||
R_DEFINE_ERROR_RESULT(InternalFileDataVerificationDateTimeExtractionFailed, 1304);
|
||||
R_DEFINE_ERROR_RESULT(InternalFileDataVerificationInvalidDateTimeLength, 1305);
|
||||
R_DEFINE_ERROR_RESULT(InternalFileDataVerificationInconsistentDateTime, 1306);
|
||||
R_DEFINE_ERROR_RESULT(InternalFileDataVerificationMakerNoteExtractionFailed, 1307);
|
||||
R_DEFINE_ERROR_RESULT(InternalFileDataVerificationInconsistentApplicationId, 1308);
|
||||
R_DEFINE_ERROR_RESULT(InternalFileDataVerificationInconsistentSignature, 1309);
|
||||
R_DEFINE_ERROR_RESULT(InternalFileDataVerificationUnsupportedOrientation, 1310);
|
||||
R_DEFINE_ERROR_RESULT(InternalFileDataVerificationInvalidDataDimension, 1311);
|
||||
R_DEFINE_ERROR_RESULT(InternalFileDataVerificationInconsistentOrientation, 1312);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(InternalAlbumLimitationError, 1400, 1499);
|
||||
R_DEFINE_ERROR_RESULT(InternalAlbumLimitationFileCountLimit, 1401);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(InternalSignatureError, 1500, 1599);
|
||||
R_DEFINE_ERROR_RESULT(InternalSignatureExifExtractionFailed, 1501);
|
||||
R_DEFINE_ERROR_RESULT(InternalSignatureMakerNoteExtractionFailed, 1502);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(InternalAlbumSessionError, 1700, 1799);
|
||||
R_DEFINE_ERROR_RESULT(InternalAlbumLimitationSessionCountLimit, 1701);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(InternalAlbumTemporaryFileError, 1900, 1999);
|
||||
R_DEFINE_ERROR_RESULT(InternalAlbumTemporaryFileCountLimit, 1901);
|
||||
R_DEFINE_ERROR_RESULT(InternalAlbumTemporaryFileCreateError, 1902);
|
||||
R_DEFINE_ERROR_RESULT(InternalAlbumTemporaryFileCreateRetryCountLimit, 1903);
|
||||
R_DEFINE_ERROR_RESULT(InternalAlbumTemporaryFileOpenError, 1904);
|
||||
R_DEFINE_ERROR_RESULT(InternalAlbumTemporaryFileGetFileSizeError, 1905);
|
||||
R_DEFINE_ERROR_RESULT(InternalAlbumTemporaryFileSetFileSizeError, 1906);
|
||||
R_DEFINE_ERROR_RESULT(InternalAlbumTemporaryFileReadFileError, 1907);
|
||||
R_DEFINE_ERROR_RESULT(InternalAlbumTemporaryFileWriteFileError, 1908);
|
||||
|
||||
}
|
||||
@@ -1,37 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::creport, 168);
|
||||
|
||||
namespace ams::creport {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(UndefinedInstruction, 0);
|
||||
R_DEFINE_ERROR_RESULT(InstructionAbort, 1);
|
||||
R_DEFINE_ERROR_RESULT(DataAbort, 2);
|
||||
R_DEFINE_ERROR_RESULT(AlignmentFault, 3);
|
||||
R_DEFINE_ERROR_RESULT(DebuggerAttached, 4);
|
||||
R_DEFINE_ERROR_RESULT(BreakPoint, 5);
|
||||
R_DEFINE_ERROR_RESULT(UserBreak, 6);
|
||||
R_DEFINE_ERROR_RESULT(DebuggerBreak, 7);
|
||||
R_DEFINE_ERROR_RESULT(UndefinedSystemCall, 8);
|
||||
R_DEFINE_ERROR_RESULT(MemorySystemError, 9);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(IncompleteReport, 99);
|
||||
|
||||
}
|
||||
@@ -1,28 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::cs, 204);
|
||||
|
||||
namespace ams::cs {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(UnknownCommand, 2);
|
||||
R_DEFINE_ERROR_RESULT(OutOfResource, 4);
|
||||
R_DEFINE_ERROR_RESULT(NoSocket, 7);
|
||||
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::dd, 6);
|
||||
|
||||
namespace ams::dd {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(EndOfQuery, 1);
|
||||
R_DEFINE_ERROR_RESULT(InvalidCurrentMemory, 2);
|
||||
R_DEFINE_ERROR_RESULT(NotSingleRegion, 3);
|
||||
R_DEFINE_ERROR_RESULT(InvalidMemoryState, 4);
|
||||
R_DEFINE_ERROR_RESULT(OutOfMemory, 5);
|
||||
R_DEFINE_ERROR_RESULT(OutOfResource, 6);
|
||||
R_DEFINE_ERROR_RESULT(NotSupported, 7);
|
||||
R_DEFINE_ERROR_RESULT(InvalidHandle, 8);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InternalError, 1023);
|
||||
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::ddsf, 30);
|
||||
|
||||
namespace ams::ddsf {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(OutOfResource, 1);
|
||||
R_DEFINE_ERROR_RESULT(NotSupported, 2);
|
||||
R_DEFINE_ERROR_RESULT(InvalidArgument, 3);
|
||||
R_DEFINE_ERROR_RESULT(PermissionDenied, 4);
|
||||
R_DEFINE_ERROR_RESULT(AccessModeDenied, 5);
|
||||
R_DEFINE_ERROR_RESULT(DeviceCodeNotFound, 6);
|
||||
|
||||
}
|
||||
@@ -1,28 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::dbg, 183);
|
||||
|
||||
namespace ams::dbg {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(CannotDebug, 1);
|
||||
R_DEFINE_ERROR_RESULT(AlreadyAttached, 2);
|
||||
R_DEFINE_ERROR_RESULT(Cancelled, 3);
|
||||
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::dmnt, 13);
|
||||
|
||||
namespace ams::dmnt {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(Unknown, 1);
|
||||
R_DEFINE_ERROR_RESULT(DebuggingDisabled, 2);
|
||||
|
||||
/* Atmosphere extension. */
|
||||
// namespace cheat {
|
||||
|
||||
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_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_NS(cheat, VirtualMachineError, 6700, 6799);
|
||||
R_DEFINE_ERROR_RESULT_NS(cheat, VirtualMachineInvalidConditionDepth, 6700);
|
||||
|
||||
// }
|
||||
|
||||
}
|
||||
@@ -1,44 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::erpt, 147);
|
||||
|
||||
namespace ams::erpt {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NotInitialized, 1);
|
||||
R_DEFINE_ERROR_RESULT(AlreadyInitialized, 2);
|
||||
R_DEFINE_ERROR_RESULT(OutOfArraySpace, 3);
|
||||
R_DEFINE_ERROR_RESULT(OutOfFieldSpace, 4);
|
||||
R_DEFINE_ERROR_RESULT(OutOfMemory, 5);
|
||||
R_DEFINE_ERROR_RESULT(NotSupported, 6);
|
||||
R_DEFINE_ERROR_RESULT(InvalidArgument, 7);
|
||||
R_DEFINE_ERROR_RESULT(NotFound, 8);
|
||||
R_DEFINE_ERROR_RESULT(FieldCategoryMismatch, 9);
|
||||
R_DEFINE_ERROR_RESULT(FieldTypeMismatch, 10);
|
||||
R_DEFINE_ERROR_RESULT(AlreadyExists, 11);
|
||||
R_DEFINE_ERROR_RESULT(CorruptJournal, 12);
|
||||
R_DEFINE_ERROR_RESULT(CategoryNotFound, 13);
|
||||
R_DEFINE_ERROR_RESULT(RequiredContextMissing, 14);
|
||||
R_DEFINE_ERROR_RESULT(RequiredFieldMissing, 15);
|
||||
R_DEFINE_ERROR_RESULT(FormatterError, 16);
|
||||
R_DEFINE_ERROR_RESULT(InvalidPowerState, 17);
|
||||
R_DEFINE_ERROR_RESULT(ArrayFieldTooLarge, 18);
|
||||
R_DEFINE_ERROR_RESULT(AlreadyOwned, 19);
|
||||
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::err, 162);
|
||||
|
||||
namespace ams::err {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(ApplicationAbort, 1);
|
||||
R_DEFINE_ERROR_RESULT(SystemProgramAbort, 2);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(ForcedShutdownDetected, 4);
|
||||
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#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 {
|
||||
|
||||
/* Result 1-1000 reserved for Atmosphere. */
|
||||
R_DEFINE_ERROR_RESULT(NotPresent, 1);
|
||||
R_DEFINE_ERROR_RESULT(VersionMismatch, 2);
|
||||
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::fatal, 163);
|
||||
|
||||
namespace ams::fatal {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(AllocationFailed, 1);
|
||||
R_DEFINE_ERROR_RESULT(NullGraphicsBuffer, 2);
|
||||
R_DEFINE_ERROR_RESULT(AlreadyThrown, 3);
|
||||
R_DEFINE_ERROR_RESULT(TooManyEvents, 4);
|
||||
R_DEFINE_ERROR_RESULT(InRepairWithoutVolHeld, 5);
|
||||
R_DEFINE_ERROR_RESULT(InRepairWithoutTimeReviserCartridge, 6);
|
||||
|
||||
}
|
||||
@@ -1,606 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::fs, 2);
|
||||
|
||||
namespace ams::fs {
|
||||
|
||||
R_DEFINE_ERROR_RANGE(HandledByAllProcess, 0, 999);
|
||||
R_DEFINE_ERROR_RESULT(PathNotFound, 1);
|
||||
R_DEFINE_ERROR_RESULT(PathAlreadyExists, 2);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(TargetLocked, 7);
|
||||
R_DEFINE_ERROR_RESULT(DirectoryNotEmpty, 8);
|
||||
|
||||
R_DEFINE_ERROR_RANGE (NotEnoughFreeSpace, 30, 45);
|
||||
R_DEFINE_ERROR_RANGE(NotEnoughFreeSpaceBis, 34, 38);
|
||||
R_DEFINE_ERROR_RESULT(NotEnoughFreeSpaceBisCalibration, 35);
|
||||
R_DEFINE_ERROR_RESULT(NotEnoughFreeSpaceBisSafe, 36);
|
||||
R_DEFINE_ERROR_RESULT(NotEnoughFreeSpaceBisUser, 37);
|
||||
R_DEFINE_ERROR_RESULT(NotEnoughFreeSpaceBisSystem, 38);
|
||||
R_DEFINE_ERROR_RESULT(NotEnoughFreeSpaceSdCard, 39);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSdkVersion, 50);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(MountNameAlreadyExists, 60);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(HandledBySystemProcess, 1000, 2999);
|
||||
R_DEFINE_ERROR_RESULT(PartitionNotFound, 1001);
|
||||
R_DEFINE_ERROR_RESULT(TargetNotFound, 1002);
|
||||
R_DEFINE_ERROR_RESULT(NcaExternalKeyNotFound, 1004);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(SdCardAccessFailed, 2000, 2499);
|
||||
R_DEFINE_ERROR_RESULT(SdCardNotPresent, 2001);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(GameCardAccessFailed, 2500, 2999);
|
||||
R_DEFINE_ERROR_RESULT(GameCardPreconditionViolation, 2503);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(GameCardCardAccessFailure, 2530, 2559);
|
||||
R_DEFINE_ERROR_RANGE(CameCardWrongCard, 2543, 2546);
|
||||
R_DEFINE_ERROR_RESULT(GameCardInitialDataMismatch, 2544);
|
||||
R_DEFINE_ERROR_RESULT(GameCardInitialNotFilledWithZero, 2545);
|
||||
R_DEFINE_ERROR_RESULT(GameCardKekIndexMismatch, 2546);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(GameCardInvalidCardHeader, 2554);
|
||||
R_DEFINE_ERROR_RESULT(GameCardInvalidT1CardCertificate, 2555);
|
||||
R_DEFINE_ERROR_RESULT(GameCardInvalidCa10Certificate, 2557);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(GameCardSplFailure, 2665, 2669);
|
||||
R_DEFINE_ERROR_RESULT(GameCardSplDecryptAesKeyFailure, 2666);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NotImplemented, 3001);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedVersion, 3002);
|
||||
R_DEFINE_ERROR_RESULT(OutOfRange, 3005);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(SystemPartitionNotReady, 3100);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(AllocationMemoryFailed, 3200, 3499);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInFatFileSystemA, 3201);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInFatFileSystemC, 3203);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInFatFileSystemD, 3204);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInFatFileSystemE, 3205);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInFatFileSystemF, 3206);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInFatFileSystemH, 3208);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInFileSystemAccessorA, 3211);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInFileSystemAccessorB, 3212);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInApplicationA, 3213);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInBcatSaveDataA, 3214);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInBisA, 3215);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInBisB, 3216);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInBisC, 3217);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInCodeA, 3218);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInContentA, 3219);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInContentStorageA, 3220);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInContentStorageB, 3221);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInDataA, 3222);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInDataB, 3223);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInDeviceSaveDataA, 3224);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardA, 3225);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardB, 3226);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardC, 3227);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardD, 3228);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInHostA, 3229);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInHostB, 3230);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInHostC, 3231);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInImageDirectoryA, 3232);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInLogoA, 3233);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInRomA, 3234);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInRomB, 3235);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInRomC, 3236);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInRomD, 3237);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInRomE, 3238);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInRomF, 3239);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSaveDataManagementA, 3242);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSaveDataThumbnailA, 3243);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSdCardA, 3244);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSdCardB, 3245);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSystemSaveDataA, 3246);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInRomFsFileSystemA, 3247);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInRomFsFileSystemB, 3248);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInRomFsFileSystemC, 3249);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGuidPartitionTableA, 3251);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInDeviceDetectionEventManagerA, 3252);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSaveDataFileSystemServiceImplA, 3253);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInFileSystemProxyCoreImplB, 3254);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSdCardProxyFileSystemCreatorA, 3255);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInNcaFileSystemServiceImplA, 3256);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInNcaFileSystemServiceImplB, 3257);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInProgramRegistryManagerA, 3258);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSdmmcStorageServiceA, 3259);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInBuiltInStorageCreatorA, 3260);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInBuiltInStorageCreatorB, 3261);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInBuiltInStorageCreatorC, 3262);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedFatFileSystemWithBufferA, 3264);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInFatFileSystemCreatorA, 3265);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInFatFileSystemCreatorB, 3266);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardFileSystemCreatorA, 3267);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardFileSystemCreatorB, 3268);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardFileSystemCreatorC, 3269);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardFileSystemCreatorD, 3270);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardFileSystemCreatorE, 3271);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardFileSystemCreatorF, 3272);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardManagerA, 3273);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardManagerB, 3274);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardManagerC, 3275);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardManagerD, 3276);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardManagerE, 3277);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardManagerF, 3278);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInLocalFileSystemCreatorA, 3279);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInPartitionFileSystemCreatorA, 3280);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInRomFileSystemCreatorA, 3281);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSaveDataFileSystemCreatorA, 3282);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSaveDataFileSystemCreatorB, 3283);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSaveDataFileSystemCreatorC, 3284);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSaveDataFileSystemCreatorD, 3285);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSaveDataFileSystemCreatorE, 3286);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInStorageOnNcaCreatorA, 3288);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInStorageOnNcaCreatorB, 3289);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSubDirectoryFileSystemCreatorA, 3290);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInTargetManagerFileSystemCreatorA, 3291);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSaveDataIndexerA, 3292);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSaveDataIndexerB, 3293);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInFileSystemBuddyHeapA, 3294);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInFileSystemBufferManagerA, 3295);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInBlockCacheBufferedStorageA, 3296);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInBlockCacheBufferedStorageB, 3297);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInDuplexStorageA, 3298);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInIntegrityVerificationStorageA, 3304);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInIntegrityVerificationStorageB, 3305);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInJournalStorageA, 3306);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInJournalStorageB, 3307);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSaveDataFileSystemCoreA, 3310);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSaveDataFileSystemCoreB, 3311);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInAesXtsFileA, 3312);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInAesXtsFileB, 3313);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInAesXtsFileC, 3314);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInAesXtsFileD, 3315);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInAesXtsFileSystemA, 3316);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInConcatenationFileSystemA, 3319);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInConcatenationFileSystemB, 3320);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInDirectorySaveDataFileSystemA, 3321);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInLocalFileSystemA, 3322);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInLocalFileSystemB, 3323);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInNcaFileSystemDriverI, 3341);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInPartitionFileSystemA, 3347);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInPartitionFileSystemB, 3348);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInPartitionFileSystemC, 3349);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInPartitionFileSystemMetaA, 3350);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInPartitionFileSystemMetaB, 3351);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInRomFsFileSystemD, 3352);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSubdirectoryFileSystemA, 3355);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInTmFileSystemA, 3356);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInTmFileSystemB, 3357);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInProxyFileSystemA, 3359);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInProxyFileSystemB, 3360);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSaveDataExtraDataAccessorCacheManagerA, 3362);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInNcaReaderA, 3363);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInRegisterA, 3365);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInRegisterB, 3366);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInPathNormalizer, 3367);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInDbmRomKeyValueStorage, 3375);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInDbmHierarchicalRomFileTable, 3376);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInRomFsFileSystemE, 3377);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInISaveFileSystemA, 3378);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInISaveFileSystemB, 3379);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInRomOnFileA, 3380);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInRomOnFileB, 3381);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInRomOnFileC, 3382);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInAesXtsFileE, 3383);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInAesXtsFileF, 3384);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInAesXtsFileG, 3385);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInReadOnlyFileSystemA, 3386);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInEncryptedFileSystemCreatorA, 3394);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInAesCtrCounterExtendedStorageA, 3399);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInAesCtrCounterExtendedStorageB, 3400);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSdmmcStorageServiceB, 3406);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInFileSystemInterfaceAdapterA, 3407);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardFileSystemCreatorG, 3408);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardFileSystemCreatorH, 3409);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInAesXtsFileSystemB, 3410);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInBufferedStorageA, 3411);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInIntegrityRomFsStorageA, 3412);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSaveDataFileSystemServiceImplB, 3416);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedNew, 3420);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInFileSystemProxyImplA, 3421);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedMakeUnique, 3422);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedAllocateShared, 3423);
|
||||
R_DEFINE_ERROR_RESULT(AllocationPooledBufferNotEnoughSize, 3424);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInWriteThroughCacheStorageA, 3428);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSaveDataTransferManagerA, 3429);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInSaveDataTransferManagerB, 3430);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInHtcFileSystemA, 3431);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInHtcFileSystemB, 3432);
|
||||
R_DEFINE_ERROR_RESULT(AllocationMemoryFailedInGameCardManagerG, 3433);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(Internal, 3000, 7999);
|
||||
R_DEFINE_ERROR_RANGE(MmcAccessFailed, 3500, 3999);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(DataCorrupted, 4000, 4999);
|
||||
R_DEFINE_ERROR_RANGE(RomCorrupted, 4001, 4299);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedRomVersion, 4002);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(AesCtrCounterExtendedStorageCorrupted, 4011, 4019);
|
||||
R_DEFINE_ERROR_RESULT(InvalidAesCtrCounterExtendedEntryOffset, 4012);
|
||||
R_DEFINE_ERROR_RESULT(InvalidAesCtrCounterExtendedTableSize, 4013);
|
||||
R_DEFINE_ERROR_RESULT(InvalidAesCtrCounterExtendedGeneration, 4014);
|
||||
R_DEFINE_ERROR_RESULT(InvalidAesCtrCounterExtendedOffset, 4015);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(IndirectStorageCorrupted, 4021, 4029);
|
||||
R_DEFINE_ERROR_RESULT(InvalidIndirectEntryOffset, 4022);
|
||||
R_DEFINE_ERROR_RESULT(InvalidIndirectEntryStorageIndex, 4023);
|
||||
R_DEFINE_ERROR_RESULT(InvalidIndirectStorageSize, 4024);
|
||||
R_DEFINE_ERROR_RESULT(InvalidIndirectVirtualOffset, 4025);
|
||||
R_DEFINE_ERROR_RESULT(InvalidIndirectPhysicalOffset, 4026);
|
||||
R_DEFINE_ERROR_RESULT(InvalidIndirectStorageIndex, 4027);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(BucketTreeCorrupted, 4031, 4039);
|
||||
R_DEFINE_ERROR_RESULT(InvalidBucketTreeSignature, 4032);
|
||||
R_DEFINE_ERROR_RESULT(InvalidBucketTreeEntryCount, 4033);
|
||||
R_DEFINE_ERROR_RESULT(InvalidBucketTreeNodeEntryCount, 4034);
|
||||
R_DEFINE_ERROR_RESULT(InvalidBucketTreeNodeOffset, 4035);
|
||||
R_DEFINE_ERROR_RESULT(InvalidBucketTreeEntryOffset, 4036);
|
||||
R_DEFINE_ERROR_RESULT(InvalidBucketTreeEntrySetOffset, 4037);
|
||||
R_DEFINE_ERROR_RESULT(InvalidBucketTreeNodeIndex, 4038);
|
||||
R_DEFINE_ERROR_RESULT(InvalidBucketTreeVirtualOffset, 4039);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(RomNcaCorrupted, 4041, 4139);
|
||||
R_DEFINE_ERROR_RANGE(RomNcaFileSystemCorrupted, 4051, 4069);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRomNcaFileSystemType, 4052);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRomAcidFileSize, 4053);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRomAcidSize, 4054);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRomAcid, 4055);
|
||||
R_DEFINE_ERROR_RESULT(RomAcidVerificationFailed, 4056);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRomNcaSignature, 4057);
|
||||
R_DEFINE_ERROR_RESULT(RomNcaHeaderSignature1VerificationFailed, 4058);
|
||||
R_DEFINE_ERROR_RESULT(RomNcaHeaderSignature2VerificationFailed, 4059);
|
||||
R_DEFINE_ERROR_RESULT(RomNcaFsHeaderHashVerificationFailed, 4060);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRomNcaKeyIndex, 4061);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRomNcaFsHeaderHashType, 4062);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRomNcaFsHeaderEncryptionType, 4063);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(RomNcaHierarchicalSha256StorageCorrupted, 4071, 4079);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRomHierarchicalSha256BlockSize, 4072);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRomHierarchicalSha256LayerCount, 4073);
|
||||
R_DEFINE_ERROR_RESULT(RomHierarchicalSha256BaseStorageTooLarge, 4074);
|
||||
R_DEFINE_ERROR_RESULT(RomHierarchicalSha256HashVerificationFailed, 4075);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(RomNcaInvalidHierarchicalIntegrityVerificationLayerCount, 4081);
|
||||
R_DEFINE_ERROR_RESULT(RomNcaInvalidNcaIndirectStorageOutOfRange, 4082);
|
||||
R_DEFINE_ERROR_RESULT(RomNcaInvalidCompressionInfo, 4083);
|
||||
R_DEFINE_ERROR_RESULT(RomNcaInvalidPatchMetaDataHashType, 4084);
|
||||
R_DEFINE_ERROR_RESULT(RomNcaInvalidIntegrityLayerInfoOffset, 4085);
|
||||
R_DEFINE_ERROR_RESULT(RomNcaInvalidPatchMetaDataHashDataSize, 4086);
|
||||
R_DEFINE_ERROR_RESULT(RomNcaInvalidPatchMetaDataHashDataOffset, 4087);
|
||||
R_DEFINE_ERROR_RESULT(RomNcaInvalidPatchMetaDataHashDataHash, 4088);
|
||||
R_DEFINE_ERROR_RESULT(RomNcaInvalidSparseMetaDataHashType, 4089);
|
||||
R_DEFINE_ERROR_RESULT(RomNcaInvalidSparseMetaDataHashDataSize, 4090);
|
||||
R_DEFINE_ERROR_RESULT(RomNcaInvalidSparseMetaDataHashDataOffset, 4091);
|
||||
R_DEFINE_ERROR_RESULT(RomNcaInvalidSparseMetaDataHashDataHash, 4092);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(RomIntegrityVerificationStorageCorrupted, 4141, 4179);
|
||||
R_DEFINE_ERROR_RESULT(IncorrectRomIntegrityVerificationMagic, 4142);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRomZeroHash, 4143);
|
||||
R_DEFINE_ERROR_RESULT(RomNonRealDataVerificationFailed, 4144);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRomHierarchicalIntegrityVerificationLayerCount, 4145);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(RomRealDataVerificationFailed, 4151, 4159);
|
||||
R_DEFINE_ERROR_RESULT(ClearedRomRealDataVerificationFailed, 4152);
|
||||
R_DEFINE_ERROR_RESULT(UnclearedRomRealDataVerificationFailed, 4153);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(RomPartitionFileSystemCorrupted, 4181, 4199);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRomSha256PartitionHashTarget, 4182);
|
||||
R_DEFINE_ERROR_RESULT(RomSha256PartitionHashVerificationFailed, 4183);
|
||||
R_DEFINE_ERROR_RESULT(RomPartitionSignatureVerificationFailed, 4184);
|
||||
R_DEFINE_ERROR_RESULT(RomSha256PartitionSignatureVerificationFailed, 4185);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRomPartitionEntryOffset, 4186);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRomSha256PartitionMetaDataSize, 4187);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(RomBuiltInStorageCorrupted, 4201, 4219);
|
||||
R_DEFINE_ERROR_RESULT(RomGptHeaderVerificationFailed, 4202);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(RomHostFileSystemCorrupted, 4241, 4259);
|
||||
R_DEFINE_ERROR_RESULT(RomHostEntryCorrupted, 4242);
|
||||
R_DEFINE_ERROR_RESULT(RomHostFileDataCorrupted, 4243);
|
||||
R_DEFINE_ERROR_RESULT(RomHostFileCorrupted, 4244);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRomHostHandle, 4245);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(RomDatabaseCorrupted, 4261, 4279);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRomAllocationTableBlock, 4262);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRomKeyValueListElementIndex, 4263);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(SaveDataCorrupted, 4301, 4499);
|
||||
R_DEFINE_ERROR_RANGE(NcaCorrupted, 4501, 4599);
|
||||
R_DEFINE_ERROR_RESULT(NcaBaseStorageOutOfRangeA, 4508);
|
||||
R_DEFINE_ERROR_RESULT(NcaBaseStorageOutOfRangeB, 4509);
|
||||
R_DEFINE_ERROR_RESULT(NcaBaseStorageOutOfRangeC, 4510);
|
||||
R_DEFINE_ERROR_RESULT(NcaBaseStorageOutOfRangeD, 4511);
|
||||
|
||||
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);
|
||||
R_DEFINE_ERROR_RESULT(InvalidAcid, 4515);
|
||||
R_DEFINE_ERROR_RESULT(AcidVerificationFailed, 4516);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNcaSignature, 4517);
|
||||
R_DEFINE_ERROR_RESULT(NcaHeaderSignature1VerificationFailed, 4518);
|
||||
R_DEFINE_ERROR_RESULT(NcaHeaderSignature2VerificationFailed, 4519);
|
||||
R_DEFINE_ERROR_RESULT(NcaFsHeaderHashVerificationFailed, 4520);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNcaKeyIndex, 4521);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNcaFsHeaderHashType, 4522);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNcaFsHeaderEncryptionType, 4523);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNcaPatchInfoIndirectSize, 4524);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNcaPatchInfoAesCtrExSize, 4525);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNcaPatchInfoAesCtrExOffset, 4526);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNcaId, 4527);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNcaHeader, 4528);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNcaFsHeader, 4529);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NcaBaseStorageOutOfRangeE, 4530);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(NcaHierarchicalSha256StorageCorrupted, 4531, 4539);
|
||||
R_DEFINE_ERROR_RESULT(InvalidHierarchicalSha256BlockSize, 4532);
|
||||
R_DEFINE_ERROR_RESULT(InvalidHierarchicalSha256LayerCount, 4533);
|
||||
R_DEFINE_ERROR_RESULT(HierarchicalSha256BaseStorageTooLarge, 4534);
|
||||
R_DEFINE_ERROR_RESULT(HierarchicalSha256HashVerificationFailed, 4535);
|
||||
|
||||
/* TODO: Range? */
|
||||
R_DEFINE_ERROR_RESULT(InvalidNcaHierarchicalIntegrityVerificationLayerCount, 4541);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNcaIndirectStorageOutOfRange, 4542);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNcaHeader1SignatureKeyGeneration, 4543);
|
||||
|
||||
/* TODO: Range? */
|
||||
R_DEFINE_ERROR_RESULT(InvalidCompressedStorageSize, 4547);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNcaMetaDataHashDataSize, 4548);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNcaMetaDataHashDataHash, 4549);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(IntegrityVerificationStorageCorrupted, 4601, 4639);
|
||||
R_DEFINE_ERROR_RESULT(IncorrectIntegrityVerificationMagic, 4602);
|
||||
R_DEFINE_ERROR_RESULT(InvalidZeroHash, 4603);
|
||||
R_DEFINE_ERROR_RESULT(NonRealDataVerificationFailed, 4604);
|
||||
R_DEFINE_ERROR_RESULT(InvalidHierarchicalIntegrityVerificationLayerCount, 4605);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(RealDataVerificationFailed, 4611, 4619);
|
||||
R_DEFINE_ERROR_RESULT(ClearedRealDataVerificationFailed, 4612);
|
||||
R_DEFINE_ERROR_RESULT(UnclearedRealDataVerificationFailed, 4613);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(PartitionFileSystemCorrupted, 4641, 4659);
|
||||
R_DEFINE_ERROR_RESULT(InvalidSha256PartitionHashTarget, 4642);
|
||||
R_DEFINE_ERROR_RESULT(Sha256PartitionHashVerificationFailed, 4643);
|
||||
R_DEFINE_ERROR_RESULT(PartitionSignatureVerificationFailed, 4644);
|
||||
R_DEFINE_ERROR_RESULT(Sha256PartitionSignatureVerificationFailed, 4645);
|
||||
R_DEFINE_ERROR_RESULT(InvalidPartitionEntryOffset, 4646);
|
||||
R_DEFINE_ERROR_RESULT(InvalidSha256PartitionMetaDataSize, 4647);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(BuiltInStorageCorrupted, 4661, 4679);
|
||||
R_DEFINE_ERROR_RESULT(GptHeaderVerificationFailed, 4662);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(FatFileSystemCorrupted, 4681, 4699);
|
||||
R_DEFINE_ERROR_RESULT(ExFatUnavailable, 4685);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(HostFileSystemCorrupted, 4701, 4719);
|
||||
R_DEFINE_ERROR_RESULT(HostEntryCorrupted, 4702);
|
||||
R_DEFINE_ERROR_RESULT(HostFileDataCorrupted, 4703);
|
||||
R_DEFINE_ERROR_RESULT(HostFileCorrupted, 4704);
|
||||
R_DEFINE_ERROR_RESULT(InvalidHostHandle, 4705);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(DatabaseCorrupted, 4721, 4739);
|
||||
R_DEFINE_ERROR_RESULT(InvalidAllocationTableBlock, 4722);
|
||||
R_DEFINE_ERROR_RESULT(InvalidKeyValueListElementIndex, 4723);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(AesXtsFileSystemCorrupted, 4741, 4759);
|
||||
R_DEFINE_ERROR_RANGE(SaveDataTransferDataCorrupted, 4761, 4769);
|
||||
R_DEFINE_ERROR_RANGE(SignedSystemPartitionDataCorrupted, 4771, 4779);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(GameCardLogoDataCorrupted, 4781);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(Unexpected, 5000, 5999);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedInLocalFileSystemA, 5305);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedInLocalFileSystemB, 5306);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedInLocalFileSystemC, 5307);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedInLocalFileSystemD, 5308);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedInLocalFileSystemE, 5309);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedInLocalFileSystemF, 5310);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedInPathOnExecutionDirectoryA, 5312);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedInPathOnExecutionDirectoryB, 5313);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedInPathOnExecutionDirectoryC, 5314);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedInAesCtrStorageA, 5315);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedInAesXtsStorageA, 5316);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedInFindFileSystemA, 5319);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedInCompressedStorageA, 5324);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedInCompressedStorageB, 5325);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedInCompressedStorageC, 5326);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedInCompressedStorageD, 5327);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedInPathA, 5328);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(PreconditionViolation, 6000, 6499);
|
||||
R_DEFINE_ERROR_RANGE(InvalidArgument, 6001, 6199);
|
||||
R_DEFINE_ERROR_RANGE(InvalidPath, 6002, 6029);
|
||||
R_DEFINE_ERROR_RESULT(TooLongPath, 6003);
|
||||
R_DEFINE_ERROR_RESULT(InvalidCharacter, 6004);
|
||||
R_DEFINE_ERROR_RESULT(InvalidPathFormat, 6005);
|
||||
R_DEFINE_ERROR_RESULT(DirectoryUnobtainable, 6006);
|
||||
R_DEFINE_ERROR_RESULT(NotNormalized, 6007);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(InvalidPathForOperation, 6030, 6059);
|
||||
R_DEFINE_ERROR_RESULT(DirectoryNotDeletable, 6031);
|
||||
R_DEFINE_ERROR_RESULT(DirectoryNotRenamable, 6032);
|
||||
R_DEFINE_ERROR_RESULT(IncompatiblePath, 6033);
|
||||
R_DEFINE_ERROR_RESULT(RenameToOtherFileSystem, 6034);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidOffset, 6061);
|
||||
R_DEFINE_ERROR_RESULT(InvalidSize, 6062);
|
||||
R_DEFINE_ERROR_RESULT(NullptrArgument, 6063);
|
||||
R_DEFINE_ERROR_RESULT(InvalidAlignment, 6064);
|
||||
R_DEFINE_ERROR_RESULT(InvalidMountName, 6065);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(ExtensionSizeTooLarge, 6066);
|
||||
R_DEFINE_ERROR_RESULT(ExtensionSizeInvalid, 6067);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidOpenMode, 6072);
|
||||
R_DEFINE_ERROR_RESULT(TooLargeSize, 6073);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(InvalidEnumValue, 6080, 6099);
|
||||
R_DEFINE_ERROR_RESULT(InvalidSaveDataState, 6081);
|
||||
R_DEFINE_ERROR_RESULT(InvalidSaveDataSpaceId, 6082);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(InvalidOperationForOpenMode, 6200, 6299);
|
||||
R_DEFINE_ERROR_RESULT(FileExtensionWithoutOpenModeAllowAppend, 6201);
|
||||
R_DEFINE_ERROR_RESULT(ReadNotPermitted, 6202);
|
||||
R_DEFINE_ERROR_RESULT(WriteNotPermitted, 6203);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(UnsupportedOperation, 6300, 6399);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForNotResizableSubStorage, 6302);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForResizableSubStorage, 6303);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForMemoryStorage, 6304);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForMemoryStorage, 6305);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForFileStorage, 6306);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForFileHandleStorage, 6307);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForSwitchStorage, 6308);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForStorageServiceObjectAdapter, 6309);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedWriteForAesCtrCounterExtendedStorage, 6310);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForAesCtrCounterExtendedStorage, 6311);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForAesCtrCounterExtendedStorage, 6312);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedWriteForAesCtrStorageExternal, 6313);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForAesCtrStorageExternal, 6314);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForAesCtrStorage, 6315);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForHierarchicalIntegrityVerificationStorage, 6316);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForHierarchicalIntegrityVerificationStorage, 6317);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForIntegrityVerificationStorage, 6318);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForWritableIntegrityVerificationStorage, 6319);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForIntegrityVerificationStorage, 6320);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForBlockCacheBufferedStorage, 6321);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForWritableBlockCacheBufferedStorage, 6322);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForBlockCacheBufferedStorage, 6323);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedWriteForIndirectStorage, 6324);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForIndirectStorage, 6325);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForIndirectStorage, 6326);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedWriteForZeroStorage, 6327);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForZeroStorage, 6328);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForHierarchicalSha256Storage, 6329);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedWriteForReadOnlyBlockCacheStorage, 6330);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForReadOnlyBlockCacheStorage, 6331);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForIntegrityRomFsStorage, 6332);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForDuplexStorage, 6333);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForDuplexStorage, 6334);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForHierarchicalDuplexStorage, 6335);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedGetSizeForRemapStorage, 6336);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForRemapStorage, 6337);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForRemapStorage, 6338);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForIntegritySaveDataStorage, 6339);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForIntegritySaveDataStorage, 6340);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForJournalIntegritySaveDataStorage, 6341);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForJournalIntegritySaveDataStorage, 6342);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedGetSizeForJournalStorage, 6343);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForJournalStorage, 6344);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForJournalStorage, 6345);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForUnionStorage, 6346);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForAllocationTableStorage, 6347);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedReadForWriteOnlyGameCardStorage, 6348);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForWriteOnlyGameCardStorage, 6349);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedWriteForReadOnlyGameCardStorage, 6350);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForReadOnlyGameCardStorage, 6351);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForReadOnlyGameCardStorage, 6352);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForSdmmcStorage, 6353);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForSdmmcStorage, 6354);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForFatFile, 6355);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForStorageFile, 6356);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForInternalStorageConcatenationFile, 6357);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForInternalStorageConcatenationFile, 6358);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedQueryEntryForConcatenationFileSystem, 6359);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForConcatenationFile, 6360);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForZeroBitmapFile, 6361);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForFileServiceObjectAdapter, 6362);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForAesXtsFile, 6363);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedWriteForRomFsFileSystem, 6364);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedCommitProvisionallyForRomFsFileSystem, 6365);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedGetTotalSpaceSizeForRomFsFileSystem, 6366);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedWriteForRomFsFile, 6367);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForRomFsFile, 6368);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedWriteForReadOnlyFileSystem, 6369);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedCommitProvisionallyForReadOnlyFileSystem, 6370);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedGetTotalSpaceSizeForReadOnlyFileSystem, 6371);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedWriteForReadOnlyFile, 6372);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForReadOnlyFile, 6373);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedWriteForPartitionFileSystem, 6374);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedCommitProvisionallyForPartitionFileSystem, 6375);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedWriteForPartitionFile, 6376);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForPartitionFile, 6377);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForTmFileSystemFile, 6378);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedWriteForSaveDataInternalStorageFileSystem, 6379);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedCommitProvisionallyForApplicationTemporaryFileSystem, 6382);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedCommitProvisionallyForSaveDataFileSystem, 6383);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedCommitProvisionallyForDirectorySaveDataFileSystem, 6384);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedWriteForZeroBitmapHashStorageFile, 6385);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedSetSizeForZeroBitmapHashStorageFile, 6386);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedWriteForCompressedStorage, 6387);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForCompressedStorage, 6388);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedOperateRangeForRegionSwitchStorage, 6397);
|
||||
|
||||
|
||||
R_DEFINE_ERROR_RANGE(PermissionDenied, 6400, 6449);
|
||||
R_DEFINE_ERROR_RESULT(PermissionDeniedForCreateHostFileSystem, 6403);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(PortAcceptableCountLimited, 6450);
|
||||
R_DEFINE_ERROR_RESULT(NcaExternalKeyUnregistered, 6451);
|
||||
R_DEFINE_ERROR_RESULT(NcaExternalKeyInconsistent, 6452);
|
||||
R_DEFINE_ERROR_RESULT(NeedFlush, 6454);
|
||||
R_DEFINE_ERROR_RESULT(FileNotClosed, 6455);
|
||||
R_DEFINE_ERROR_RESULT(DirectoryNotClosed, 6456);
|
||||
R_DEFINE_ERROR_RESULT(WriteModeFileNotClosed, 6457);
|
||||
R_DEFINE_ERROR_RESULT(AllocatorAlreadyRegistered, 6458);
|
||||
R_DEFINE_ERROR_RESULT(DefaultAllocatorUsed, 6459);
|
||||
R_DEFINE_ERROR_RESULT(AllocatorAlignmentViolation, 6461);
|
||||
R_DEFINE_ERROR_RESULT(UserNotExist, 6465);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(NotFound, 6600, 6699);
|
||||
R_DEFINE_ERROR_RESULT(ProgramInfoNotFound, 6605);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(OutOfResource, 6700, 6799);
|
||||
R_DEFINE_ERROR_RESULT(BufferAllocationFailed, 6705);
|
||||
R_DEFINE_ERROR_RESULT(MappingTableFull, 6706);
|
||||
R_DEFINE_ERROR_RESULT(OpenCountLimit, 6709);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(MappingFailed, 6800, 6899);
|
||||
R_DEFINE_ERROR_RESULT(MapFull, 6811);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(BadState, 6900, 6999);
|
||||
R_DEFINE_ERROR_RESULT(NotInitialized, 6902);
|
||||
R_DEFINE_ERROR_RESULT(NotMounted, 6905);
|
||||
|
||||
|
||||
R_DEFINE_ERROR_RANGE(DbmNotFound, 7901, 7904);
|
||||
R_DEFINE_ERROR_RESULT(DbmKeyNotFound, 7902);
|
||||
R_DEFINE_ERROR_RESULT(DbmFileNotFound, 7903);
|
||||
R_DEFINE_ERROR_RESULT(DbmDirectoryNotFound, 7904);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(DbmAlreadyExists, 7906);
|
||||
R_DEFINE_ERROR_RESULT(DbmKeyFull, 7907);
|
||||
R_DEFINE_ERROR_RESULT(DbmDirectoryEntryFull, 7908);
|
||||
R_DEFINE_ERROR_RESULT(DbmFileEntryFull, 7909);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(DbmFindFinished, 7910, 7912);
|
||||
R_DEFINE_ERROR_RESULT(DbmFindKeyFinished, 7911);
|
||||
R_DEFINE_ERROR_RESULT(DbmIterationFinished, 7912);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(DbmInvalidOperation, 7914);
|
||||
R_DEFINE_ERROR_RESULT(DbmInvalidPathFormat, 7915);
|
||||
R_DEFINE_ERROR_RESULT(DbmDirectoryNameTooLong, 7916);
|
||||
R_DEFINE_ERROR_RESULT(DbmFileNameTooLong, 7917);
|
||||
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::gpio, 102);
|
||||
|
||||
namespace ams::gpio {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(AlreadyBound, 1);
|
||||
R_DEFINE_ERROR_RESULT(AlreadyOpen, 2);
|
||||
R_DEFINE_ERROR_RESULT(DeviceNotFound, 3);
|
||||
R_DEFINE_ERROR_RESULT(InvalidArgument, 4);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NotOpen, 6);
|
||||
|
||||
}
|
||||
@@ -1,42 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::sf::hipc, 11);
|
||||
|
||||
namespace ams::sf::hipc {
|
||||
|
||||
R_DEFINE_ABSTRACT_ERROR_RANGE(OutOfResource, 100, 299);
|
||||
R_DEFINE_ERROR_RESULT(OutOfSessionMemory, 102);
|
||||
R_DEFINE_ERROR_RANGE (OutOfSessions, 131, 139);
|
||||
R_DEFINE_ERROR_RESULT(PointerBufferTooSmall, 141);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(OutOfDomains, 200);
|
||||
|
||||
R_DEFINE_ABSTRACT_ERROR_RANGE(CommunicationError, 300, 349);
|
||||
R_DEFINE_ERROR_RESULT(SessionClosed, 301);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidRequestSize, 402);
|
||||
R_DEFINE_ERROR_RESULT(UnknownCommandType, 403);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidCmifRequest, 420);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(TargetNotDomain, 491);
|
||||
R_DEFINE_ERROR_RESULT(DomainObjectNotFound, 492);
|
||||
|
||||
}
|
||||
@@ -1,42 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::htc, 18);
|
||||
|
||||
namespace ams::htc {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(ConnectionFailure, 1);
|
||||
R_DEFINE_ERROR_RESULT(NotFound, 2);
|
||||
R_DEFINE_ERROR_RESULT(NotEnoughBuffer, 3);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(Cancelled, 101);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(Unknown, 1023);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(Unknown2001, 2001);
|
||||
R_DEFINE_ERROR_RESULT(InvalidTaskId, 2003);
|
||||
R_DEFINE_ERROR_RESULT(InvalidSize, 2011);
|
||||
R_DEFINE_ERROR_RESULT(TaskCancelled, 2021);
|
||||
R_DEFINE_ERROR_RESULT(TaskNotCompleted, 2022);
|
||||
R_DEFINE_ERROR_RESULT(TaskQueueNotAvailable, 2033);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(Unknown2101, 2101);
|
||||
R_DEFINE_ERROR_RESULT(OutOfRpcTask, 2102);
|
||||
R_DEFINE_ERROR_RESULT(InvalidCategory, 2123);
|
||||
|
||||
}
|
||||
@@ -1,45 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::htcfs, 31);
|
||||
|
||||
namespace ams::htcfs {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidArgument, 3);
|
||||
|
||||
|
||||
R_DEFINE_ERROR_RANGE(ConnectionFailure, 100, 199);
|
||||
R_DEFINE_ERROR_RESULT(HtclowChannelClosed, 101);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(UnexpectedResponse, 110, 119);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedResponseProtocolId, 111);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedResponseProtocolVersion, 112);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedResponsePacketCategory, 113);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedResponsePacketType, 114);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedResponseBodySize, 115);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedResponseBody, 116);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(InternalError, 200, 299);
|
||||
R_DEFINE_ERROR_RESULT(InvalidSize, 201);
|
||||
R_DEFINE_ERROR_RESULT(UnknownError, 211);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedProtocolVersion, 212);
|
||||
R_DEFINE_ERROR_RESULT(InvalidRequest, 213);
|
||||
R_DEFINE_ERROR_RESULT(InvalidHandle, 214);
|
||||
R_DEFINE_ERROR_RESULT(OutOfHandle, 215);
|
||||
|
||||
}
|
||||
@@ -1,77 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::htclow, 29);
|
||||
|
||||
namespace ams::htclow {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(ConnectionFailure, 1);
|
||||
R_DEFINE_ERROR_RESULT(UnknownDriverType, 3);
|
||||
R_DEFINE_ERROR_RESULT(NonBlockingReceiveFailed, 5);
|
||||
R_DEFINE_ERROR_RESULT(ChannelWaitCancelled, 8);
|
||||
R_DEFINE_ERROR_RESULT(ChannelAlreadyExist, 9);
|
||||
R_DEFINE_ERROR_RESULT(ChannelNotExist, 10);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(OutOfChannel, 151);
|
||||
R_DEFINE_ERROR_RESULT(OutOfTask, 152);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidChannelState, 200);
|
||||
R_DEFINE_ERROR_RESULT(InvalidChannelStateDisconnected, 201);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(InternalError, 1000, 2999);
|
||||
R_DEFINE_ERROR_RESULT(Overflow, 1001);
|
||||
R_DEFINE_ERROR_RESULT(OutOfMemory, 1002);
|
||||
R_DEFINE_ERROR_RESULT(InvalidArgument, 1003);
|
||||
R_DEFINE_ERROR_RESULT(ProtocolError, 1004);
|
||||
R_DEFINE_ERROR_RESULT(Cancelled, 1005);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(MuxError, 1100, 1199);
|
||||
R_DEFINE_ERROR_RESULT(ChannelBufferOverflow, 1101);
|
||||
R_DEFINE_ERROR_RESULT(ChannelBufferHasNotEnoughData, 1102);
|
||||
R_DEFINE_ERROR_RESULT(ChannelVersionNotMatched, 1103);
|
||||
R_DEFINE_ERROR_RESULT(ChannelStateTransitionError, 1104);
|
||||
R_DEFINE_ERROR_RESULT(ChannelReceiveBufferEmpty, 1106);
|
||||
R_DEFINE_ERROR_RESULT(ChannelSequenceIdNotMatched, 1107);
|
||||
R_DEFINE_ERROR_RESULT(ChannelCannotDiscard, 1108);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(DriverError, 1200, 1999);
|
||||
R_DEFINE_ERROR_RESULT(DriverOpened, 1201);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(SocketDriverError, 1300, 1399);
|
||||
R_DEFINE_ERROR_RESULT(SocketSocketExemptError, 1301);
|
||||
R_DEFINE_ERROR_RESULT(SocketBindError, 1302);
|
||||
R_DEFINE_ERROR_RESULT(SocketListenError, 1304);
|
||||
R_DEFINE_ERROR_RESULT(SocketAcceptError, 1305);
|
||||
R_DEFINE_ERROR_RESULT(SocketReceiveError, 1306);
|
||||
R_DEFINE_ERROR_RESULT(SocketSendError, 1307);
|
||||
R_DEFINE_ERROR_RESULT(SocketReceiveFromError, 1308);
|
||||
R_DEFINE_ERROR_RESULT(SocketSendToError, 1309);
|
||||
R_DEFINE_ERROR_RESULT(SocketSetSockOptError, 1310);
|
||||
R_DEFINE_ERROR_RESULT(SocketGetSockNameError, 1311);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(UsbDriverError, 1400, 1499);
|
||||
R_DEFINE_ERROR_RESULT(UsbDriverUnknownError, 1401);
|
||||
R_DEFINE_ERROR_RESULT(UsbDriverBusyError, 1402);
|
||||
R_DEFINE_ERROR_RESULT(UsbDriverReceiveError, 1403);
|
||||
R_DEFINE_ERROR_RESULT(UsbDriverSendError, 1404);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(HtcctrlError, 2000); /* TODO: Range? */
|
||||
R_DEFINE_ERROR_RESULT(HtcctrlStateTransitionNotAllowed, 2001);
|
||||
R_DEFINE_ERROR_RESULT(HtcctrlReceiveUnexpectedPacket, 2002);
|
||||
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::htcs, 4);
|
||||
|
||||
namespace ams::htcs {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidHandle, 9);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidArgument, 2001);
|
||||
R_DEFINE_ERROR_RESULT(InvalidServerHandle, 2003);
|
||||
R_DEFINE_ERROR_RESULT(InvalidSize, 2014);
|
||||
R_DEFINE_ERROR_RESULT(Cancelled, 2021);
|
||||
R_DEFINE_ERROR_RESULT(Completed, 2023);
|
||||
R_DEFINE_ERROR_RESULT(InvalidTask, 2103);
|
||||
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::i2c, 101);
|
||||
|
||||
namespace ams::i2c {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NoAck, 1);
|
||||
R_DEFINE_ERROR_RESULT(BusBusy, 2);
|
||||
R_DEFINE_ERROR_RESULT(CommandListFull, 3);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(UnknownDevice, 5);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(Timeout, 253);
|
||||
|
||||
}
|
||||
@@ -1,33 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::kvdb, 20);
|
||||
|
||||
namespace ams::kvdb {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(OutOfKeyResource, 1);
|
||||
R_DEFINE_ERROR_RESULT(KeyNotFound, 2);
|
||||
R_DEFINE_ERROR_RESULT(AllocationFailed, 4);
|
||||
R_DEFINE_ERROR_RESULT(InvalidKeyValue, 5);
|
||||
R_DEFINE_ERROR_RESULT(BufferInsufficient, 6);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidFilesystemState, 8);
|
||||
R_DEFINE_ERROR_RESULT(NotCreated, 9);
|
||||
|
||||
}
|
||||
@@ -1,69 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::ldr, 9);
|
||||
|
||||
namespace ams::ldr {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(ArgumentOverflow, 1);
|
||||
R_DEFINE_ERROR_RESULT(ArgumentCountOverflow, 2);
|
||||
R_DEFINE_ERROR_RESULT(MetaOverflow, 3);
|
||||
R_DEFINE_ERROR_RESULT(InvalidMeta, 4);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNso, 5);
|
||||
R_DEFINE_ERROR_RESULT(InvalidPath, 6);
|
||||
R_DEFINE_ERROR_RESULT(MaxProcess, 7);
|
||||
R_DEFINE_ERROR_RESULT(NotPinned, 8);
|
||||
R_DEFINE_ERROR_RESULT(InvalidProgramId, 9);
|
||||
R_DEFINE_ERROR_RESULT(InvalidVersion, 10);
|
||||
R_DEFINE_ERROR_RESULT(InvalidAcidSignature, 11);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNcaSignature, 12);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidProgramAttributes, 14);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(OutOfAddressSpace, 51);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNroImage, 52);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNrrImage, 53);
|
||||
R_DEFINE_ERROR_RESULT(NotAuthorized, 54);
|
||||
R_DEFINE_ERROR_RESULT(MaxModule, 55);
|
||||
R_DEFINE_ERROR_RESULT(MaxRegistration, 56);
|
||||
R_DEFINE_ERROR_RESULT(NroAlreadyLoaded, 57);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidAddress, 81);
|
||||
R_DEFINE_ERROR_RESULT(InvalidSize, 82);
|
||||
R_DEFINE_ERROR_RESULT(InvalidCurrentMemory, 83);
|
||||
R_DEFINE_ERROR_RESULT(NotLoaded, 84);
|
||||
R_DEFINE_ERROR_RESULT(NotRegistered, 85);
|
||||
R_DEFINE_ERROR_RESULT(InvalidSession, 86);
|
||||
R_DEFINE_ERROR_RESULT(InvalidProcess, 87);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(UnknownCapability, 100);
|
||||
R_DEFINE_ERROR_RESULT(InvalidCapabilityKernelFlags, 103);
|
||||
R_DEFINE_ERROR_RESULT(InvalidCapabilitySyscallMask, 104);
|
||||
R_DEFINE_ERROR_RESULT(InvalidCapabilityMapRange, 106);
|
||||
R_DEFINE_ERROR_RESULT(InvalidCapabilityMapPage, 107);
|
||||
R_DEFINE_ERROR_RESULT(InvalidCapabilityMapRegion, 110);
|
||||
R_DEFINE_ERROR_RESULT(InvalidCapabilityInterruptPair, 111);
|
||||
R_DEFINE_ERROR_RESULT(InvalidCapabilityApplicationType, 113);
|
||||
R_DEFINE_ERROR_RESULT(InvalidCapabilityKernelVersion, 114);
|
||||
R_DEFINE_ERROR_RESULT(InvalidCapabilityHandleTable, 115);
|
||||
R_DEFINE_ERROR_RESULT(InvalidCapabilityDebugFlags, 116);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InternalError, 200);
|
||||
|
||||
}
|
||||
@@ -1,37 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::lr, 8);
|
||||
|
||||
namespace ams::lr {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(ProgramNotFound, 2);
|
||||
R_DEFINE_ERROR_RESULT(DataNotFound, 3);
|
||||
R_DEFINE_ERROR_RESULT(UnknownStorageId, 4);
|
||||
R_DEFINE_ERROR_RESULT(HtmlDocumentNotFound, 6);
|
||||
R_DEFINE_ERROR_RESULT(AddOnContentNotFound, 7);
|
||||
R_DEFINE_ERROR_RESULT(ControlNotFound, 8);
|
||||
R_DEFINE_ERROR_RESULT(LegalInformationNotFound, 9);
|
||||
R_DEFINE_ERROR_RESULT(DebugProgramNotFound, 10);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(TooManyRegisteredPaths, 90);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidPath, 140);
|
||||
|
||||
}
|
||||
@@ -1,87 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::ncm, 5);
|
||||
|
||||
namespace ams::ncm {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidContentStorageBase, 1);
|
||||
R_DEFINE_ERROR_RESULT(PlaceHolderAlreadyExists, 2);
|
||||
R_DEFINE_ERROR_RESULT(PlaceHolderNotFound, 3);
|
||||
R_DEFINE_ERROR_RESULT(ContentAlreadyExists, 4);
|
||||
R_DEFINE_ERROR_RESULT(ContentNotFound, 5);
|
||||
R_DEFINE_ERROR_RESULT(ContentMetaNotFound, 7);
|
||||
R_DEFINE_ERROR_RESULT(AllocationFailed, 8);
|
||||
R_DEFINE_ERROR_RESULT(UnknownStorage, 12);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidContentStorage, 100);
|
||||
R_DEFINE_ERROR_RESULT(InvalidContentMetaDatabase, 110);
|
||||
R_DEFINE_ERROR_RESULT(InvalidPackageFormat, 130);
|
||||
R_DEFINE_ERROR_RESULT(InvalidContentHash, 140);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidInstallTaskState, 160);
|
||||
R_DEFINE_ERROR_RESULT(InvalidPlaceHolderFile, 170);
|
||||
R_DEFINE_ERROR_RESULT(BufferInsufficient, 180);
|
||||
R_DEFINE_ERROR_RESULT(NotSupported, 190);
|
||||
R_DEFINE_ERROR_RESULT(NotEnoughInstallSpace, 200);
|
||||
R_DEFINE_ERROR_RESULT(SystemUpdateNotFoundInPackage, 210);
|
||||
R_DEFINE_ERROR_RESULT(ContentInfoNotFound, 220);
|
||||
R_DEFINE_ERROR_RESULT(DeltaNotFound, 237);
|
||||
R_DEFINE_ERROR_RESULT(InvalidContentMetaKey, 240);
|
||||
R_DEFINE_ERROR_RESULT(FragmentIndicatorNotFound, 242);
|
||||
R_DEFINE_ERROR_RESULT(IgnorableInstallTicketFailure, 280);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(ContentStorageBaseNotFound, 310);
|
||||
R_DEFINE_ERROR_RESULT(ListPartiallyNotCommitted, 330);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedContentMetaPrepared, 360);
|
||||
R_DEFINE_ERROR_RESULT(InvalidFirmwareVariation, 380);
|
||||
R_DEFINE_ERROR_RESULT(InvalidContentMetaFileSize, 390);
|
||||
R_DEFINE_ERROR_RESULT(InvalidAddOnContentMetaExtendedHeader, 400);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidContentMetaDirectory, 430);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(ContentStorageNotActive, 250, 258);
|
||||
R_DEFINE_ERROR_RESULT(GameCardContentStorageNotActive, 251);
|
||||
R_DEFINE_ERROR_RESULT(BuiltInSystemContentStorageNotActive, 252);
|
||||
R_DEFINE_ERROR_RESULT(BuiltInUserContentStorageNotActive, 253);
|
||||
R_DEFINE_ERROR_RESULT(SdCardContentStorageNotActive, 254);
|
||||
R_DEFINE_ERROR_RESULT(UnknownContentStorageNotActive, 258);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(ContentMetaDatabaseNotActive, 260, 268);
|
||||
R_DEFINE_ERROR_RESULT(GameCardContentMetaDatabaseNotActive, 261);
|
||||
R_DEFINE_ERROR_RESULT(BuiltInSystemContentMetaDatabaseNotActive, 262);
|
||||
R_DEFINE_ERROR_RESULT(BuiltInUserContentMetaDatabaseNotActive, 263);
|
||||
R_DEFINE_ERROR_RESULT(SdCardContentMetaDatabaseNotActive, 264);
|
||||
R_DEFINE_ERROR_RESULT(UnknownContentMetaDatabaseNotActive, 268);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(InstallTaskCancelled, 290, 299);
|
||||
R_DEFINE_ERROR_RESULT(CreatePlaceHolderCancelled, 291);
|
||||
R_DEFINE_ERROR_RESULT(WritePlaceHolderCancelled, 292);
|
||||
|
||||
/* TODO: Range */
|
||||
R_DEFINE_ERROR_RESULT(MapperBusy, 1010);
|
||||
R_DEFINE_ERROR_RESULT(MapperInvalidArgument, 1030);
|
||||
R_DEFINE_ERROR_RESULT(MapperNotSupported, 1040);
|
||||
R_DEFINE_ERROR_RESULT(MapperNotMapped, 1050);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidOperation, 8180);
|
||||
R_DEFINE_ERROR_RANGE(InvalidArgument, 8181, 8191);
|
||||
R_DEFINE_ERROR_RESULT(InvalidOffset, 8182);
|
||||
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::nim, 137);
|
||||
|
||||
namespace ams::nim {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(HttpConnectionCanceled, 70);
|
||||
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::ns, 16);
|
||||
|
||||
namespace ams::ns {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(Canceled, 90);
|
||||
R_DEFINE_ERROR_RESULT(OutOfMaxRunningTask, 110);
|
||||
R_DEFINE_ERROR_RESULT(CardUpdateNotSetup, 270);
|
||||
R_DEFINE_ERROR_RESULT(CardUpdateNotPrepared, 280);
|
||||
R_DEFINE_ERROR_RESULT(CardUpdateAlreadySetup, 290);
|
||||
R_DEFINE_ERROR_RESULT(PrepareCardUpdateAlreadyRequested, 460);
|
||||
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::os, 3);
|
||||
|
||||
namespace ams::os {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(Busy, 4);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidParameter, 7);
|
||||
R_DEFINE_ERROR_RESULT(OutOfMemory, 8);
|
||||
R_DEFINE_ERROR_RESULT(OutOfResource, 9);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(OutOfVirtualAddressSpace, 12);
|
||||
R_DEFINE_ERROR_RESULT(ResourceLimit, 13);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(OutOfHandles, 500);
|
||||
R_DEFINE_ERROR_RESULT(InvalidHandle, 501);
|
||||
R_DEFINE_ERROR_RESULT(InvalidCurrentMemoryState, 502);
|
||||
R_DEFINE_ERROR_RESULT(InvalidTransferMemoryState, 503);
|
||||
R_DEFINE_ERROR_RESULT(InvalidTransferMemorySize, 504);
|
||||
R_DEFINE_ERROR_RESULT(OutOfTransferMemory, 505);
|
||||
R_DEFINE_ERROR_RESULT(OutOfAddressSpace, 506);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(SessionClosedForReceive, 510);
|
||||
R_DEFINE_ERROR_RESULT(SessionClosedForReply, 511);
|
||||
R_DEFINE_ERROR_RESULT(ReceiveListBroken, 512);
|
||||
R_DEFINE_ERROR_RESULT(InvalidProcessMemory, 513);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NotImplemented, 1000);
|
||||
R_DEFINE_ERROR_RESULT(NotSupported, 1001);
|
||||
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::osdbg, 7);
|
||||
|
||||
namespace ams::osdbg {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(CannotGetThreadInfo, 1);
|
||||
R_DEFINE_ERROR_RESULT(UnsupportedThreadVersion, 2);
|
||||
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::pcv, 133);
|
||||
|
||||
namespace ams::pcv {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(IllegalRequest, 16);
|
||||
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::pgl, 228);
|
||||
|
||||
namespace ams::pgl {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NotImplemented, 1);
|
||||
R_DEFINE_ERROR_RESULT(NotAvailable, 2);
|
||||
R_DEFINE_ERROR_RESULT(ApplicationNotRunning, 3);
|
||||
R_DEFINE_ERROR_RESULT(BufferNotEnough, 4);
|
||||
R_DEFINE_ERROR_RESULT(ApplicationContentNotFound, 5);
|
||||
R_DEFINE_ERROR_RESULT(ContentMetaNotFound, 6);
|
||||
R_DEFINE_ERROR_RESULT(OutOfMemory, 7);
|
||||
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::pm, 15);
|
||||
|
||||
namespace ams::pm {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(ProcessNotFound, 1);
|
||||
R_DEFINE_ERROR_RESULT(AlreadyStarted, 2);
|
||||
R_DEFINE_ERROR_RESULT(NotTerminated, 3);
|
||||
R_DEFINE_ERROR_RESULT(DebugHookInUse, 4);
|
||||
R_DEFINE_ERROR_RESULT(ApplicationRunning, 5);
|
||||
R_DEFINE_ERROR_RESULT(InvalidSize, 6);
|
||||
R_DEFINE_ERROR_RESULT(Unknown7, 7);
|
||||
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::powctl, 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);
|
||||
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::psc, 138);
|
||||
|
||||
namespace ams::psc {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(AlreadyInitialized, 2);
|
||||
R_DEFINE_ERROR_RESULT(NotInitialized, 3);
|
||||
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::pwm, 189);
|
||||
|
||||
namespace ams::pwm {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidArgument, 2);
|
||||
|
||||
}
|
||||
@@ -1,548 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/common.hpp>
|
||||
#include <vapours/assert.hpp>
|
||||
|
||||
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;
|
||||
static_assert(std::is_same<BaseType, ::Result>::value, "std::is_same<BaseType, ::Result>::value");
|
||||
static constexpr BaseType SuccessValue = BaseType();
|
||||
static constexpr BaseType ModuleBits = 9;
|
||||
static constexpr BaseType DescriptionBits = 13;
|
||||
static constexpr BaseType ReservedBits = 10;
|
||||
static_assert(ModuleBits + DescriptionBits + ReservedBits == sizeof(BaseType) * CHAR_BIT, "ModuleBits + DescriptionBits + ReservedBits == sizeof(BaseType) * CHAR_BIT");
|
||||
private:
|
||||
static constexpr ALWAYS_INLINE BaseType GetBitsValue(BaseType v, int ofs, int num) {
|
||||
return (v >> ofs) & ~(~BaseType() << num);
|
||||
}
|
||||
public:
|
||||
static constexpr ALWAYS_INLINE BaseType MakeValue(BaseType module, BaseType description) {
|
||||
return (module) | (description << ModuleBits);
|
||||
}
|
||||
|
||||
template<BaseType module, BaseType description>
|
||||
struct MakeStaticValue : public std::integral_constant<BaseType, MakeValue(module, description)> {
|
||||
static_assert(module < (1 << ModuleBits), "Invalid Module");
|
||||
static_assert(description < (1 << DescriptionBits), "Invalid Description");
|
||||
};
|
||||
|
||||
static constexpr ALWAYS_INLINE BaseType GetModuleFromValue(BaseType value) {
|
||||
return GetBitsValue(value, 0, ModuleBits);
|
||||
}
|
||||
|
||||
static constexpr ALWAYS_INLINE BaseType GetDescriptionFromValue(BaseType value) {
|
||||
return GetBitsValue(value, ModuleBits, DescriptionBits);
|
||||
}
|
||||
|
||||
static constexpr ALWAYS_INLINE BaseType GetReservedFromValue(BaseType value) {
|
||||
return GetBitsValue(value, ModuleBits + DescriptionBits, ReservedBits);
|
||||
}
|
||||
|
||||
static constexpr ALWAYS_INLINE BaseType MaskReservedFromValue(BaseType value) {
|
||||
return value & ~(~(~BaseType() << ReservedBits) << (ModuleBits + DescriptionBits));
|
||||
}
|
||||
|
||||
static constexpr ALWAYS_INLINE BaseType MergeValueWithReserved(BaseType value, BaseType reserved) {
|
||||
return (value << 0) | (reserved << (ModuleBits + DescriptionBits));
|
||||
}
|
||||
};
|
||||
|
||||
/* Use CRTP for Results. */
|
||||
class ResultBase {
|
||||
public:
|
||||
using BaseType = typename ResultTraits::BaseType;
|
||||
static constexpr BaseType SuccessValue = ResultTraits::SuccessValue;
|
||||
public:
|
||||
constexpr ALWAYS_INLINE BaseType GetModule(this auto const &self) { return ResultTraits::GetModuleFromValue(self.GetValue()); }
|
||||
constexpr ALWAYS_INLINE BaseType GetDescription(this auto const &self) { return ResultTraits::GetDescriptionFromValue(self.GetValue()); }
|
||||
};
|
||||
|
||||
class ResultInternalAccessor;
|
||||
|
||||
}
|
||||
|
||||
class ResultSuccess;
|
||||
|
||||
class Result final : public result::impl::ResultBase {
|
||||
friend class result::impl::ResultInternalAccessor;
|
||||
public:
|
||||
using Base = typename result::impl::ResultBase;
|
||||
private:
|
||||
typename Base::BaseType m_value;
|
||||
private:
|
||||
/* TODO: Maybe one-day, the result constructor. */
|
||||
public:
|
||||
Result() { /* ... */ }
|
||||
|
||||
/* TODO: It sure would be nice to make this private. */
|
||||
constexpr ALWAYS_INLINE Result(typename Base::BaseType v) : m_value(v) { static_assert(std::is_same<typename Base::BaseType, ::Result>::value); }
|
||||
|
||||
constexpr ALWAYS_INLINE operator ResultSuccess() const;
|
||||
static constexpr ALWAYS_INLINE bool CanAccept(Result) { return true; }
|
||||
|
||||
constexpr ALWAYS_INLINE bool IsSuccess() const { return m_value == Base::SuccessValue; }
|
||||
constexpr ALWAYS_INLINE bool IsFailure() const { return !this->IsSuccess(); }
|
||||
constexpr ALWAYS_INLINE typename Base::BaseType GetModule() const { return Base::GetModule(); }
|
||||
constexpr ALWAYS_INLINE typename Base::BaseType GetDescription() const { return Base::GetDescription(); }
|
||||
|
||||
constexpr ALWAYS_INLINE typename Base::BaseType GetInnerValue() const { return ::ams::result::impl::ResultTraits::MaskReservedFromValue(m_value); }
|
||||
|
||||
constexpr ALWAYS_INLINE typename Base::BaseType GetValue() const { return m_value; }
|
||||
};
|
||||
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 {
|
||||
public:
|
||||
static constexpr ALWAYS_INLINE Result MakeResult(ResultTraits::BaseType value) {
|
||||
return Result(value);
|
||||
}
|
||||
|
||||
static constexpr ALWAYS_INLINE ResultTraits::BaseType GetReserved(Result result) {
|
||||
return ResultTraits::GetReservedFromValue(result.m_value);
|
||||
}
|
||||
|
||||
static constexpr ALWAYS_INLINE Result MergeReserved(Result result, ResultTraits::BaseType reserved) {
|
||||
return Result(ResultTraits::MergeValueWithReserved(ResultTraits::MaskReservedFromValue(result.m_value), reserved));
|
||||
}
|
||||
};
|
||||
|
||||
constexpr ALWAYS_INLINE Result MakeResult(ResultTraits::BaseType value) {
|
||||
return ResultInternalAccessor::MakeResult(value);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
class ResultSuccess final : public result::impl::ResultBase {
|
||||
public:
|
||||
using Base = typename result::impl::ResultBase;
|
||||
public:
|
||||
constexpr ALWAYS_INLINE operator Result() const { return result::impl::MakeResult(Base::SuccessValue); }
|
||||
static constexpr ALWAYS_INLINE bool CanAccept(Result result) { return result.IsSuccess(); }
|
||||
|
||||
constexpr ALWAYS_INLINE bool IsSuccess() const { return true; }
|
||||
constexpr ALWAYS_INLINE bool IsFailure() const { return !this->IsSuccess(); }
|
||||
|
||||
constexpr ALWAYS_INLINE typename Base::BaseType GetValue() const { return Base::SuccessValue; }
|
||||
};
|
||||
|
||||
namespace result::impl {
|
||||
|
||||
NORETURN NOINLINE void OnResultAssertion(const char *file, int line, const char *func, const char *expr, Result result);
|
||||
NORETURN NOINLINE void OnResultAssertion(Result result);
|
||||
NORETURN NOINLINE void OnResultAbort(const char *file, int line, const char *func, const char *expr, Result result);
|
||||
NORETURN NOINLINE void OnResultAbort(Result result);
|
||||
|
||||
}
|
||||
|
||||
constexpr ALWAYS_INLINE Result::operator ResultSuccess() const {
|
||||
if (!ResultSuccess::CanAccept(*this)) {
|
||||
result::impl::OnResultAbort(*this);
|
||||
}
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
namespace result::impl {
|
||||
|
||||
template<ResultTraits::BaseType _Module, ResultTraits::BaseType _Description>
|
||||
class ResultErrorBase : public ResultBase {
|
||||
public:
|
||||
using Base = typename result::impl::ResultBase;
|
||||
static constexpr typename Base::BaseType Module = _Module;
|
||||
static constexpr typename Base::BaseType Description = _Description;
|
||||
static constexpr typename Base::BaseType Value = ResultTraits::MakeStaticValue<Module, Description>::value;
|
||||
static_assert(Value != Base::SuccessValue, "Value != Base::SuccessValue");
|
||||
public:
|
||||
constexpr ALWAYS_INLINE operator Result() const { return MakeResult(Value); }
|
||||
constexpr ALWAYS_INLINE operator ResultSuccess() const {
|
||||
OnResultAbort(Value);
|
||||
__builtin_unreachable();
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
constexpr ALWAYS_INLINE bool IsSuccess() const { return false; }
|
||||
constexpr ALWAYS_INLINE bool IsFailure() const { return !this->IsSuccess(); }
|
||||
|
||||
constexpr ALWAYS_INLINE typename Base::BaseType GetValue() const { return Value; }
|
||||
};
|
||||
|
||||
template<ResultTraits::BaseType _Module, ResultTraits::BaseType DescStart, ResultTraits::BaseType DescEnd>
|
||||
class ResultErrorRangeBase {
|
||||
private:
|
||||
/* NOTE: GCC does not optimize the module/description comparisons into one check (as of 10/1/2021) */
|
||||
/* and so this optimizes result comparisons to get the same codegen as Nintendo does. */
|
||||
static constexpr bool UseDirectValueComparison = true;
|
||||
public:
|
||||
static constexpr ResultTraits::BaseType Module = _Module;
|
||||
static constexpr ResultTraits::BaseType DescriptionStart = DescStart;
|
||||
static constexpr ResultTraits::BaseType DescriptionEnd = DescEnd;
|
||||
static_assert(DescriptionStart <= DescriptionEnd, "DescriptionStart <= DescriptionEnd");
|
||||
static constexpr typename ResultTraits::BaseType StartValue = ResultTraits::MakeStaticValue<Module, DescriptionStart>::value;
|
||||
static constexpr typename ResultTraits::BaseType EndValue = ResultTraits::MakeStaticValue<Module, DescriptionEnd>::value;
|
||||
public:
|
||||
static constexpr ALWAYS_INLINE bool Includes(Result result) {
|
||||
if constexpr (UseDirectValueComparison) {
|
||||
const auto inner_value = result.GetInnerValue();
|
||||
if constexpr (StartValue == EndValue) {
|
||||
return inner_value == StartValue;
|
||||
} else {
|
||||
return StartValue <= inner_value && inner_value <= EndValue;
|
||||
}
|
||||
} else {
|
||||
return result.GetModule() == Module && DescriptionStart <= result.GetDescription() && result.GetDescription() <= DescriptionEnd;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#if defined(ATMOSPHERE_BOARD_NINTENDO_NX) && defined(ATMOSPHERE_ARCH_ARM64) && defined(ATMOSPHERE_IS_STRATOSPHERE)
|
||||
namespace diag::impl {
|
||||
|
||||
void FatalErrorByResultForNx(Result result) noexcept NORETURN;
|
||||
|
||||
}
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
/* Macros for defining new results. */
|
||||
#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))
|
||||
|
||||
#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."
|
||||
#endif
|
||||
|
||||
#undef R_SUCCEEDED
|
||||
|
||||
#ifndef R_FAILED
|
||||
#error "R_FAILED not defined"
|
||||
#endif
|
||||
|
||||
#undef R_FAILED
|
||||
|
||||
#define R_SUCCEEDED(res) (static_cast<::ams::Result>(res).IsSuccess())
|
||||
#define R_FAILED(res) (static_cast<::ams::Result>(res).IsFailure())
|
||||
|
||||
|
||||
/* NOTE: The following are experimental and cannot be safely used yet. */
|
||||
/* =================================================================== */
|
||||
constinit inline ::ams::Result __TmpCurrentResultReference = ::ams::ResultSuccess();
|
||||
|
||||
namespace ams::result::impl {
|
||||
|
||||
template<auto EvaluateResult, class F>
|
||||
class ScopedResultGuard {
|
||||
NON_COPYABLE(ScopedResultGuard);
|
||||
NON_MOVEABLE(ScopedResultGuard);
|
||||
private:
|
||||
Result &m_ref;
|
||||
F m_f;
|
||||
public:
|
||||
constexpr ALWAYS_INLINE ScopedResultGuard(Result &ref, F f) : m_ref(ref), m_f(std::move(f)) { }
|
||||
constexpr ALWAYS_INLINE ~ScopedResultGuard() { if (EvaluateResult(m_ref)) { m_f(); } }
|
||||
};
|
||||
|
||||
template<auto EvaluateResult>
|
||||
class ResultReferenceForScopedResultGuard {
|
||||
private:
|
||||
Result &m_ref;
|
||||
public:
|
||||
constexpr ALWAYS_INLINE ResultReferenceForScopedResultGuard(Result &r) : m_ref(r) { /* ... */ }
|
||||
|
||||
constexpr ALWAYS_INLINE operator Result &() const { return m_ref; }
|
||||
};
|
||||
|
||||
template<auto EvaluateResult, typename F>
|
||||
constexpr ALWAYS_INLINE ScopedResultGuard<EvaluateResult, F> operator+(ResultReferenceForScopedResultGuard<EvaluateResult> ref, F&& f) {
|
||||
return ScopedResultGuard<EvaluateResult, F>(static_cast<Result &>(ref), std::forward<F>(f));
|
||||
}
|
||||
|
||||
constexpr ALWAYS_INLINE bool EvaluateResultSuccess(const ::ams::Result &r) { return R_SUCCEEDED(r); }
|
||||
constexpr ALWAYS_INLINE bool EvaluateResultFailure(const ::ams::Result &r) { return R_FAILED(r); }
|
||||
|
||||
template<typename R>
|
||||
constexpr ALWAYS_INLINE bool EvaluateResultIncludedImplForSuccessCompatibility(const ::ams::Result &r) {
|
||||
if constexpr (std::same_as<R, ::ams::ResultSuccess>) {
|
||||
return R_SUCCEEDED(r);
|
||||
} else {
|
||||
return R::Includes(r);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename... Rs>
|
||||
constexpr ALWAYS_INLINE bool EvaluateAnyResultIncludes(const ::ams::Result &r) { return (EvaluateResultIncludedImplForSuccessCompatibility<Rs>(r) || ...); }
|
||||
|
||||
template<typename... Rs>
|
||||
constexpr ALWAYS_INLINE bool EvaluateResultNotIncluded(const ::ams::Result &r) { return !EvaluateAnyResultIncludes<Rs...>(r); }
|
||||
|
||||
}
|
||||
|
||||
#define AMS_DECLARE_CURRENT_RESULT_REFERENCE_AND_STORAGE(COUNTER_VALUE) \
|
||||
[[maybe_unused]] constexpr bool HasPrevRef_##COUNTER_VALUE = std::same_as<decltype(__TmpCurrentResultReference), Result &>; \
|
||||
[[maybe_unused]] auto &PrevRef_##COUNTER_VALUE = __TmpCurrentResultReference; \
|
||||
[[maybe_unused]] Result __tmp_result_##COUNTER_VALUE = ResultSuccess(); \
|
||||
::ams::Result &__TmpCurrentResultReference = HasPrevRef_##COUNTER_VALUE ? PrevRef_##COUNTER_VALUE : __tmp_result_##COUNTER_VALUE
|
||||
|
||||
#define ON_RESULT_RETURN_IMPL(...) \
|
||||
static_assert(std::same_as<decltype(__TmpCurrentResultReference), Result &>); \
|
||||
auto ANONYMOUS_VARIABLE(RESULT_GUARD_STATE_) = ::ams::result::impl::ResultReferenceForScopedResultGuard<__VA_ARGS__>(__TmpCurrentResultReference) + [&]() ALWAYS_INLINE_LAMBDA
|
||||
|
||||
#define ON_RESULT_FAILURE_2 ON_RESULT_RETURN_IMPL(::ams::result::impl::EvaluateResultFailure)
|
||||
|
||||
#define ON_RESULT_FAILURE \
|
||||
AMS_DECLARE_CURRENT_RESULT_REFERENCE_AND_STORAGE(__COUNTER__); \
|
||||
ON_RESULT_FAILURE_2
|
||||
|
||||
#define ON_RESULT_SUCCESS_2 ON_RESULT_RETURN_IMPL(::ams::result::impl::EvaluateResultSuccess)
|
||||
|
||||
#define ON_RESULT_SUCCESS \
|
||||
AMS_DECLARE_CURRENT_RESULT_REFERENCE_AND_STORAGE(__COUNTER__); \
|
||||
ON_RESULT_SUCCESS_2
|
||||
|
||||
#define ON_RESULT_INCLUDED_2(...) ON_RESULT_RETURN_IMPL(::ams::result::impl::EvaluateAnyResultIncludes<__VA_ARGS__>)
|
||||
|
||||
#define ON_RESULT_INCLUDED(...) \
|
||||
AMS_DECLARE_CURRENT_RESULT_REFERENCE_AND_STORAGE(__COUNTER__); \
|
||||
ON_RESULT_INCLUDED_2(__VA_ARGS__)
|
||||
|
||||
#define ON_RESULT_NOT_INCLUDED_2(...) ON_RESULT_RETURN_IMPL(::ams::result::impl::EvaluateResultNotIncluded<__VA_ARGS__>)
|
||||
|
||||
#define ON_RESULT_NOT_INCLUDED(...) \
|
||||
AMS_DECLARE_CURRENT_RESULT_REFERENCE_AND_STORAGE(__COUNTER__); \
|
||||
ON_RESULT_NOT_INCLUDED_2(__VA_ARGS__)
|
||||
|
||||
#define ON_RESULT_FAILURE_BESIDES(...) ON_RESULT_NOT_INCLUDED(::ams::ResultSuccess, ## __VA_ARGS__)
|
||||
|
||||
#define ON_RESULT_FAILURE_BESIDES_2(...) ON_RESULT_NOT_INCLUDED_2(::ams::ResultSuccess, ## __VA_ARGS__)
|
||||
|
||||
/* =================================================================== */
|
||||
|
||||
/// Returns a result.
|
||||
#define R_RETURN(res_expr) \
|
||||
{ \
|
||||
const ::ams::Result _tmp_r_throw_rc = (res_expr); \
|
||||
if constexpr (std::same_as<decltype(__TmpCurrentResultReference), ::ams::Result &>) { __TmpCurrentResultReference = _tmp_r_throw_rc; } \
|
||||
return _tmp_r_throw_rc; \
|
||||
}
|
||||
|
||||
/// Returns ResultSuccess()
|
||||
#define R_SUCCEED() R_RETURN(::ams::ResultSuccess())
|
||||
|
||||
/// Throws a result.
|
||||
#define R_THROW(res_expr) R_RETURN(res_expr)
|
||||
|
||||
/// Evaluates an expression that returns a result, and returns the result if it would fail.
|
||||
#define R_TRY(res_expr) \
|
||||
{ \
|
||||
if (const auto _tmp_r_try_rc = (res_expr); R_FAILED(_tmp_r_try_rc)) { \
|
||||
R_THROW(_tmp_r_try_rc); \
|
||||
} \
|
||||
}
|
||||
|
||||
#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, static_cast<::ams::Result>(val).GetModule(), static_cast<::ams::Result>(val).GetDescription(), static_cast<::ams::Result>(val).GetInnerValue())
|
||||
#else
|
||||
#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(static_cast<::ams::Result>(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, static_cast<::ams::Result>(val).GetModule(), static_cast<::ams::Result>(val).GetDescription(), static_cast<::ams::Result>(val).GetInnerValue(), ::ams::GetResultName(static_cast<::ams::Result>(val)))
|
||||
#endif
|
||||
|
||||
/// Evaluates an expression that returns a result, and asserts the result if it would fail.
|
||||
#ifdef AMS_ENABLE_ASSERTIONS
|
||||
#define R_ASSERT(res_expr) \
|
||||
{ \
|
||||
if (const auto _tmp_r_assert_rc = (res_expr); AMS_UNLIKELY(R_FAILED(_tmp_r_assert_rc))) { \
|
||||
AMS_CALL_ON_RESULT_ASSERTION_IMPL(#res_expr, _tmp_r_assert_rc); \
|
||||
} \
|
||||
}
|
||||
#else
|
||||
#define R_ASSERT(res_expr) AMS_UNUSED((res_expr));
|
||||
#endif
|
||||
|
||||
/// Evaluates an expression that returns a result, and aborts if the result would fail.
|
||||
#define R_ABORT_UNLESS(res_expr) \
|
||||
{ \
|
||||
if (const auto _tmp_r_abort_rc = (res_expr); AMS_UNLIKELY(R_FAILED(_tmp_r_abort_rc))) { \
|
||||
AMS_CALL_ON_RESULT_ABORT_IMPL(#res_expr, _tmp_r_abort_rc); \
|
||||
} \
|
||||
}
|
||||
|
||||
/// Evaluates a boolean expression, and returns a result unless that expression is true.
|
||||
#define R_UNLESS(expr, res) \
|
||||
{ \
|
||||
if (!(expr)) { \
|
||||
R_THROW(res); \
|
||||
} \
|
||||
}
|
||||
|
||||
/// Evaluates a boolean expression, and succeeds if that expression is true.
|
||||
#define R_SUCCEED_IF(expr) R_UNLESS(!(expr), ResultSuccess())
|
||||
|
||||
/// Helpers for pattern-matching on a result expression, if the result would fail.
|
||||
#define R_CURRENT_RESULT _tmp_r_try_catch_current_result
|
||||
|
||||
#define R_TRY_CATCH(res_expr) \
|
||||
{ \
|
||||
const auto R_CURRENT_RESULT = (res_expr); \
|
||||
if (R_FAILED(R_CURRENT_RESULT)) { \
|
||||
if (false)
|
||||
|
||||
#define R_CATCH(...) \
|
||||
} else if (::ams::result::impl::EvaluateAnyResultIncludes<__VA_ARGS__>(R_CURRENT_RESULT)) { \
|
||||
if (true)
|
||||
|
||||
#define R_CATCH_MODULE(__module__) \
|
||||
} else if ((R_CURRENT_RESULT).GetModule() == ::ams::R_NAMESPACE_MODULE_ID(__module__)) { \
|
||||
if (true)
|
||||
|
||||
#define R_CONVERT(catch_type, convert_type) \
|
||||
R_CATCH(catch_type) { R_THROW(static_cast<::ams::Result>(convert_type)); }
|
||||
|
||||
#define R_CATCH_ALL() \
|
||||
} else if (R_FAILED(R_CURRENT_RESULT)) { \
|
||||
if (true)
|
||||
|
||||
#define R_CONVERT_ALL(convert_type) \
|
||||
R_CATCH_ALL() { R_THROW(static_cast<::ams::Result>(convert_type)); }
|
||||
|
||||
#define R_CATCH_RETHROW(catch_type) \
|
||||
R_CONVERT(catch_type, R_CURRENT_RESULT)
|
||||
|
||||
#define R_END_TRY_CATCH \
|
||||
else if (R_FAILED(R_CURRENT_RESULT)) { \
|
||||
R_THROW(R_CURRENT_RESULT); \
|
||||
} \
|
||||
} \
|
||||
}
|
||||
|
||||
#define R_END_TRY_CATCH_WITH_ASSERT \
|
||||
else { \
|
||||
R_ASSERT(R_CURRENT_RESULT); \
|
||||
} \
|
||||
} \
|
||||
}
|
||||
|
||||
|
||||
#define R_END_TRY_CATCH_WITH_ABORT_UNLESS \
|
||||
else { \
|
||||
R_ABORT_UNLESS(R_CURRENT_RESULT); \
|
||||
} \
|
||||
} \
|
||||
}
|
||||
|
||||
|
||||
@@ -1,45 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::ro, 22);
|
||||
|
||||
namespace ams::ro {
|
||||
|
||||
R_DEFINE_ERROR_RANGE(RoError, 1, 1023);
|
||||
R_DEFINE_ERROR_RESULT(OutOfAddressSpace, 2);
|
||||
R_DEFINE_ERROR_RESULT(AlreadyLoaded, 3);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNro, 4);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidNrr, 6);
|
||||
R_DEFINE_ERROR_RESULT(TooManyNro, 7);
|
||||
R_DEFINE_ERROR_RESULT(TooManyNrr, 8);
|
||||
R_DEFINE_ERROR_RESULT(NotAuthorized, 9);
|
||||
R_DEFINE_ERROR_RESULT(InvalidNrrKind, 10);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InternalError, 1023);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidAddress, 1025);
|
||||
R_DEFINE_ERROR_RESULT(InvalidSize, 1026);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NotLoaded, 1028);
|
||||
R_DEFINE_ERROR_RESULT(NotRegistered, 1029);
|
||||
R_DEFINE_ERROR_RESULT(InvalidSession, 1030);
|
||||
R_DEFINE_ERROR_RESULT(InvalidProcess, 1031);
|
||||
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
#include <vapours/results/cs_results.hpp>
|
||||
|
||||
namespace ams::scs {
|
||||
|
||||
using ams::cs::ResultUnknownCommand;
|
||||
using ams::cs::ResultOutOfResource;
|
||||
using ams::cs::ResultNoSocket;
|
||||
|
||||
}
|
||||
@@ -1,105 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::sdmmc, 24);
|
||||
|
||||
namespace ams::sdmmc {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NoDevice, 1);
|
||||
R_DEFINE_ERROR_RESULT(NotActivated, 2);
|
||||
R_DEFINE_ERROR_RESULT(DeviceRemoved, 3);
|
||||
R_DEFINE_ERROR_RESULT(NotAwakened, 4);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(CommunicationError, 32, 126);
|
||||
R_DEFINE_ERROR_RANGE(CommunicationNotAttained, 33, 46);
|
||||
R_DEFINE_ERROR_RESULT(ResponseIndexError, 34);
|
||||
R_DEFINE_ERROR_RESULT(ResponseEndBitError, 35);
|
||||
R_DEFINE_ERROR_RESULT(ResponseCrcError, 36);
|
||||
R_DEFINE_ERROR_RESULT(ResponseTimeoutError, 37);
|
||||
R_DEFINE_ERROR_RESULT(DataEndBitError, 38);
|
||||
R_DEFINE_ERROR_RESULT(DataCrcError, 39);
|
||||
R_DEFINE_ERROR_RESULT(DataTimeoutError, 40);
|
||||
R_DEFINE_ERROR_RESULT(AutoCommandResponseIndexError, 41);
|
||||
R_DEFINE_ERROR_RESULT(AutoCommandResponseEndBitError, 42);
|
||||
R_DEFINE_ERROR_RESULT(AutoCommandResponseCrcError, 43);
|
||||
R_DEFINE_ERROR_RESULT(AutoCommandResponseTimeoutError, 44);
|
||||
R_DEFINE_ERROR_RESULT(CommandCompleteSoftwareTimeout, 45);
|
||||
R_DEFINE_ERROR_RESULT(TransferCompleteSoftwareTimeout, 46);
|
||||
R_DEFINE_ERROR_RANGE(DeviceStatusHasError, 48, 70);
|
||||
R_DEFINE_ERROR_RESULT(DeviceStatusAddressOutOfRange, 49);
|
||||
R_DEFINE_ERROR_RESULT(DeviceStatusAddressMisaligned, 50);
|
||||
R_DEFINE_ERROR_RESULT(DeviceStatusBlockLenError, 51);
|
||||
R_DEFINE_ERROR_RESULT(DeviceStatusEraseSeqError, 52);
|
||||
R_DEFINE_ERROR_RESULT(DeviceStatusEraseParam, 53);
|
||||
R_DEFINE_ERROR_RESULT(DeviceStatusWpViolation, 54);
|
||||
R_DEFINE_ERROR_RESULT(DeviceStatusLockUnlockFailed, 55);
|
||||
R_DEFINE_ERROR_RESULT(DeviceStatusComCrcError, 56);
|
||||
R_DEFINE_ERROR_RESULT(DeviceStatusIllegalCommand, 57);
|
||||
R_DEFINE_ERROR_RESULT(DeviceStatusDeviceEccFailed, 58);
|
||||
R_DEFINE_ERROR_RESULT(DeviceStatusCcError, 59);
|
||||
R_DEFINE_ERROR_RESULT(DeviceStatusError, 60);
|
||||
R_DEFINE_ERROR_RESULT(DeviceStatusCidCsdOverwrite, 61);
|
||||
R_DEFINE_ERROR_RESULT(DeviceStatusWpEraseSkip, 62);
|
||||
R_DEFINE_ERROR_RESULT(DeviceStatusEraseReset, 63);
|
||||
R_DEFINE_ERROR_RESULT(DeviceStatusSwitchError, 64);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedDeviceState, 72);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedDeviceCsdValue, 73);
|
||||
R_DEFINE_ERROR_RESULT(AbortTransactionSoftwareTimeout, 74);
|
||||
R_DEFINE_ERROR_RESULT(CommandInhibitCmdSoftwareTimeout, 75);
|
||||
R_DEFINE_ERROR_RESULT(CommandInhibitDatSoftwareTimeout, 76);
|
||||
R_DEFINE_ERROR_RESULT(BusySoftwareTimeout, 77);
|
||||
R_DEFINE_ERROR_RESULT(IssueTuningCommandSoftwareTimeout, 78);
|
||||
R_DEFINE_ERROR_RESULT(TuningFailed, 79);
|
||||
R_DEFINE_ERROR_RESULT(MmcInitializationSoftwareTimeout, 80);
|
||||
R_DEFINE_ERROR_RESULT(MmcNotSupportExtendedCsd, 81);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedMmcExtendedCsdValue, 82);
|
||||
R_DEFINE_ERROR_RESULT(MmcEraseSoftwareTimeout, 83);
|
||||
R_DEFINE_ERROR_RESULT(SdCardValidationError, 84);
|
||||
R_DEFINE_ERROR_RESULT(SdCardInitializationSoftwareTimeout, 85);
|
||||
R_DEFINE_ERROR_RESULT(SdCardGetValidRcaSoftwareTimeout, 86);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedSdCardAcmdDisabled, 87);
|
||||
R_DEFINE_ERROR_RESULT(SdCardNotSupportSwitchFunctionStatus, 88);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedSdCardSwitchFunctionStatus, 89);
|
||||
R_DEFINE_ERROR_RESULT(SdCardNotSupportAccessMode, 90);
|
||||
R_DEFINE_ERROR_RESULT(SdCardNot4BitBusWidthAtUhsIMode, 91);
|
||||
R_DEFINE_ERROR_RESULT(SdCardNotSupportSdr104AndSdr50, 92);
|
||||
R_DEFINE_ERROR_RESULT(SdCardCannotSwitchAccessMode, 93);
|
||||
R_DEFINE_ERROR_RESULT(SdCardFailedSwitchAccessMode, 94);
|
||||
R_DEFINE_ERROR_RESULT(SdCardUnacceptableCurrentConsumption, 95);
|
||||
R_DEFINE_ERROR_RESULT(SdCardNotReadyToVoltageSwitch, 96);
|
||||
R_DEFINE_ERROR_RESULT(SdCardNotCompleteVoltageSwitch, 97);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(HostControllerUnexpected, 128, 158);
|
||||
R_DEFINE_ERROR_RESULT(InternalClockStableSoftwareTimeout, 129);
|
||||
R_DEFINE_ERROR_RESULT(SdHostStandardUnknownAutoCmdError, 130);
|
||||
R_DEFINE_ERROR_RESULT(SdHostStandardUnknownError, 131);
|
||||
R_DEFINE_ERROR_RESULT(SdmmcDllCalibrationSoftwareTimeout, 132);
|
||||
R_DEFINE_ERROR_RESULT(SdmmcDllApplicationSoftwareTimeout, 133);
|
||||
R_DEFINE_ERROR_RESULT(SdHostStandardFailSwitchTo1_8V, 134);
|
||||
R_DEFINE_ERROR_RESULT(DriveStrengthCalibrationNotCompleted, 135);
|
||||
R_DEFINE_ERROR_RESULT(DriveStrengthCalibrationSoftwareTimeout, 136);
|
||||
R_DEFINE_ERROR_RESULT(SdmmcCompShortToGnd, 137);
|
||||
R_DEFINE_ERROR_RESULT(SdmmcCompOpen, 138);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(InternalError, 160, 190);
|
||||
R_DEFINE_ERROR_RESULT(NoWaitedInterrupt, 161);
|
||||
R_DEFINE_ERROR_RESULT(WaitInterruptSoftwareTimeout, 162);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NotImplemented, 201);
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::settings, 105);
|
||||
|
||||
namespace ams::settings {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(SettingsItemNotFound, 11);
|
||||
R_DEFINE_ERROR_RESULT(StopIteration, 21);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(InternalError, 100, 149);
|
||||
R_DEFINE_ERROR_RESULT(SettingsItemKeyAllocationFailed, 101);
|
||||
R_DEFINE_ERROR_RESULT(SettingsItemValueAllocationFailed, 102);
|
||||
R_DEFINE_ERROR_RESULT(SettingsItemKeyIteratorAllocationFailed, 111);
|
||||
R_DEFINE_ERROR_RESULT(TooLargeSystemSaveData, 141);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(InvalidArgument, 200, 399);
|
||||
R_DEFINE_ERROR_RESULT(NullSettingsName, 201);
|
||||
R_DEFINE_ERROR_RESULT(NullSettingsItemKey, 202);
|
||||
R_DEFINE_ERROR_RESULT(NullSettingsItemValue, 203);
|
||||
R_DEFINE_ERROR_RESULT(NullSettingsItemKeyBuffer, 204);
|
||||
R_DEFINE_ERROR_RESULT(NullSettingsItemValueBuffer, 205);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(EmptySettingsName, 221);
|
||||
R_DEFINE_ERROR_RESULT(EmptySettingsItemKey, 222);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(TooLongSettingsName, 241);
|
||||
R_DEFINE_ERROR_RESULT(TooLongSettingsItemKey, 242);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidFormatSettingsName, 261);
|
||||
R_DEFINE_ERROR_RESULT(InvalidFormatSettingsItemKey, 262);
|
||||
R_DEFINE_ERROR_RESULT(InvalidFormatSettingsItemValue, 263);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NotFoundSettingsItemKeyIterator, 281);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(CalibrationDataError, 580, 599);
|
||||
R_DEFINE_ERROR_RESULT(CalibrationDataFileSystemCorrupted, 581);
|
||||
R_DEFINE_ERROR_RESULT(CalibrationDataCrcError, 582);
|
||||
R_DEFINE_ERROR_RESULT(CalibrationDataShaError, 583);
|
||||
|
||||
}
|
||||
@@ -1,54 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::sf, 10);
|
||||
|
||||
namespace ams::sf {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NotSupported, 1);
|
||||
R_DEFINE_ERROR_RESULT(PreconditionViolation, 3);
|
||||
|
||||
//namespace cmif {
|
||||
|
||||
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_NS(cmif, TargetNotFound, 261);
|
||||
|
||||
R_DEFINE_ERROR_RESULT_NS(cmif, OutOfDomainEntries, 301);
|
||||
|
||||
//}
|
||||
|
||||
//namespace impl {
|
||||
|
||||
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);
|
||||
|
||||
}
|
||||
@@ -1,42 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::sm, 21);
|
||||
|
||||
namespace ams::sm {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(OutOfProcesses, 1);
|
||||
R_DEFINE_ERROR_RESULT(InvalidClient, 2);
|
||||
R_DEFINE_ERROR_RESULT(OutOfSessions, 3);
|
||||
R_DEFINE_ERROR_RESULT(AlreadyRegistered, 4);
|
||||
R_DEFINE_ERROR_RESULT(OutOfServices, 5);
|
||||
R_DEFINE_ERROR_RESULT(InvalidServiceName, 6);
|
||||
R_DEFINE_ERROR_RESULT(NotRegistered, 7);
|
||||
R_DEFINE_ERROR_RESULT(NotAllowed, 8);
|
||||
R_DEFINE_ERROR_RESULT(TooLargeAccessControl, 9);
|
||||
|
||||
/* Results 1000-2000 used as extension for Atmosphere Mitm. */
|
||||
//namespace mitm {
|
||||
|
||||
R_DEFINE_ERROR_RESULT_NS(mitm, ShouldForwardToSession, 1000);
|
||||
R_DEFINE_ERROR_RESULT_NS(mitm, ProcessNotAssociated, 1100);
|
||||
|
||||
//}
|
||||
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::socket, 27);
|
||||
|
||||
namespace ams::socket {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InsufficientProvidedMemory, 1);
|
||||
|
||||
}
|
||||
@@ -1,43 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::spl, 26);
|
||||
|
||||
namespace ams::spl {
|
||||
|
||||
R_DEFINE_ERROR_RANGE(SecureMonitorError, 0, 99);
|
||||
R_DEFINE_ERROR_RESULT(SecureMonitorNotSupported, 1);
|
||||
R_DEFINE_ERROR_RESULT(SecureMonitorInvalidArgument, 2);
|
||||
R_DEFINE_ERROR_RESULT(SecureMonitorBusy, 3);
|
||||
R_DEFINE_ERROR_RESULT(SecureMonitorNoAsyncOperation, 4);
|
||||
R_DEFINE_ERROR_RESULT(SecureMonitorInvalidAsyncOperation, 5);
|
||||
R_DEFINE_ERROR_RESULT(SecureMonitorNotPermitted, 6);
|
||||
R_DEFINE_ERROR_RESULT(SecureMonitorNotInitialized, 7);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidBufferSize, 100);
|
||||
R_DEFINE_ERROR_RESULT(UnexpectedSecureMonitorResult, 101);
|
||||
R_DEFINE_ERROR_RESULT(DecryptionFailed, 102);
|
||||
R_DEFINE_ERROR_RESULT(InvalidDeviceUniqueDataType, 103);
|
||||
R_DEFINE_ERROR_RESULT(NoAvailableKeySlot, 104);
|
||||
R_DEFINE_ERROR_RESULT(InvalidKeySlot, 105);
|
||||
R_DEFINE_ERROR_RESULT(BootReasonAlreadyInitialized, 106);
|
||||
R_DEFINE_ERROR_RESULT(BootReasonNotInitialized, 107);
|
||||
R_DEFINE_ERROR_RESULT(InvalidArgument, 108);
|
||||
|
||||
}
|
||||
@@ -1,44 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::sprofile, 246);
|
||||
|
||||
namespace ams::sprofile {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidArgument, 100);
|
||||
R_DEFINE_ERROR_RESULT(InvalidState, 101);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NotPermitted, 303);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(AllocationFailed, 401);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(KeyNotFound, 600);
|
||||
R_DEFINE_ERROR_RESULT(InvalidDataType, 601);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(MaxListeners, 620);
|
||||
R_DEFINE_ERROR_RESULT(AlreadyListening, 621);
|
||||
R_DEFINE_ERROR_RESULT(NotListening, 622);
|
||||
R_DEFINE_ERROR_RESULT(MaxObservers, 623);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidMetadataVersion, 3210);
|
||||
R_DEFINE_ERROR_RESULT(InvalidMetadataHash, 3211);
|
||||
R_DEFINE_ERROR_RESULT(InvalidDataVersion, 3230);
|
||||
R_DEFINE_ERROR_RESULT(InvalidDataHash, 3231);
|
||||
|
||||
}
|
||||
@@ -1,81 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::svc, 1);
|
||||
|
||||
namespace ams::svc {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(OutOfSessions, 7);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidArgument, 14);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NotImplemented, 33);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(StopProcessingException, 54);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NoSynchronizationObject, 57);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(TerminationRequested, 59);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NoEvent, 70);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidSize, 101);
|
||||
R_DEFINE_ERROR_RESULT(InvalidAddress, 102);
|
||||
R_DEFINE_ERROR_RESULT(OutOfResource, 103);
|
||||
R_DEFINE_ERROR_RESULT(OutOfMemory, 104);
|
||||
R_DEFINE_ERROR_RESULT(OutOfHandles, 105);
|
||||
R_DEFINE_ERROR_RESULT(InvalidCurrentMemory, 106);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidNewMemoryPermission, 108);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidMemoryRegion, 110);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidPriority, 112);
|
||||
R_DEFINE_ERROR_RESULT(InvalidCoreId, 113);
|
||||
R_DEFINE_ERROR_RESULT(InvalidHandle, 114);
|
||||
R_DEFINE_ERROR_RESULT(InvalidPointer, 115);
|
||||
R_DEFINE_ERROR_RESULT(InvalidCombination, 116);
|
||||
R_DEFINE_ERROR_RESULT(TimedOut, 117);
|
||||
R_DEFINE_ERROR_RESULT(Cancelled, 118);
|
||||
R_DEFINE_ERROR_RESULT(OutOfRange, 119);
|
||||
R_DEFINE_ERROR_RESULT(InvalidEnumValue, 120);
|
||||
R_DEFINE_ERROR_RESULT(NotFound, 121);
|
||||
R_DEFINE_ERROR_RESULT(Busy, 122);
|
||||
R_DEFINE_ERROR_RESULT(SessionClosed, 123);
|
||||
R_DEFINE_ERROR_RESULT(NotHandled, 124);
|
||||
R_DEFINE_ERROR_RESULT(InvalidState, 125);
|
||||
R_DEFINE_ERROR_RESULT(ReservedUsed, 126);
|
||||
R_DEFINE_ERROR_RESULT(NotSupported, 127);
|
||||
R_DEFINE_ERROR_RESULT(Debug, 128);
|
||||
R_DEFINE_ERROR_RESULT(NoThread, 129);
|
||||
R_DEFINE_ERROR_RESULT(UnknownThread, 130);
|
||||
R_DEFINE_ERROR_RESULT(PortClosed, 131);
|
||||
R_DEFINE_ERROR_RESULT(LimitReached, 132);
|
||||
R_DEFINE_ERROR_RESULT(InvalidMemoryPool, 133);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(ReceiveListBroken, 258);
|
||||
R_DEFINE_ERROR_RESULT(OutOfAddressSpace, 259);
|
||||
R_DEFINE_ERROR_RESULT(MessageTooLarge, 260);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidProcessId, 517);
|
||||
R_DEFINE_ERROR_RESULT(InvalidThreadId, 518);
|
||||
R_DEFINE_ERROR_RESULT(InvalidId, 519);
|
||||
R_DEFINE_ERROR_RESULT(ProcessTerminated, 520);
|
||||
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::time, 116);
|
||||
|
||||
namespace ams::time {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NotInitialized, 0);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NotComparable, 200);
|
||||
R_DEFINE_ERROR_RESULT(Overflowed, 201);
|
||||
|
||||
R_DEFINE_ABSTRACT_ERROR_RANGE(InvalidArgument, 900, 919);
|
||||
R_DEFINE_ERROR_RESULT(InvalidPointer, 901);
|
||||
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::tipc, 35);
|
||||
|
||||
namespace ams::tipc {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(InvalidMethod, 10);
|
||||
R_DEFINE_ERROR_RESULT(InvalidMessageFormat, 15);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(RequestDeferred, 100);
|
||||
R_DEFINE_ERROR_RESULT(SessionClosed, 101);
|
||||
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::tma, 12);
|
||||
|
||||
namespace ams::tma {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(Unknown, 1);
|
||||
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::updater, 158);
|
||||
|
||||
namespace ams::updater {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(BootImagePackageNotFound, 2);
|
||||
R_DEFINE_ERROR_RESULT(InvalidBootImagePackage, 3);
|
||||
R_DEFINE_ERROR_RESULT(TooSmallWorkBuffer, 4);
|
||||
R_DEFINE_ERROR_RESULT(NotAlignedWorkBuffer, 5);
|
||||
R_DEFINE_ERROR_RESULT(NeedsRepairBootImages, 6);
|
||||
|
||||
}
|
||||
@@ -1,37 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::usb, 140);
|
||||
|
||||
namespace ams::usb {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(NotInitialized, 0);
|
||||
R_DEFINE_ERROR_RESULT(AlreadyInitialized, 1);
|
||||
|
||||
R_DEFINE_ERROR_RANGE(InvalidParameter, 100, 199);
|
||||
R_DEFINE_ERROR_RESULT(AlignmentError, 103);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(OperationDenied, 201);
|
||||
R_DEFINE_ERROR_RESULT(MemAllocFailure, 202);
|
||||
R_DEFINE_ERROR_RESULT(ResourceBusy, 206);
|
||||
R_DEFINE_ERROR_RESULT(InternalStateError, 207);
|
||||
|
||||
R_DEFINE_ERROR_RESULT(TransactionError, 401);
|
||||
R_DEFINE_ERROR_RESULT(Interrupted, 409);
|
||||
|
||||
}
|
||||
@@ -1,28 +0,0 @@
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <vapours/results/results_common.hpp>
|
||||
|
||||
R_DEFINE_NAMESPACE_RESULT_MODULE(ams::vi, 114);
|
||||
|
||||
namespace ams::vi {
|
||||
|
||||
R_DEFINE_ERROR_RESULT(OperationFailed, 1);
|
||||
R_DEFINE_ERROR_RESULT(NotSupported, 6);
|
||||
R_DEFINE_ERROR_RESULT(NotFound, 7);
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user