OmniNX/Atmosphere
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ams: globally prefer R_RETURN to return for ams::Result

Browse Source
This commit is contained in:
Michael Scire
2022-03-26 14:48:33 -07:00
parent dd78ede99f
commit bbf22b4c60
325 changed files with 1955 additions and 1993 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
libraries/libstratosphere/source/fssystem/fssystem_aes_ctr_counter_extended_storage.cpp
View File

@@ -76,7 +76,7 @@ namespace ams::fssystem {
R_TRY(CreateSoftwareDecryptor(std::addressof(sw_decryptor)));
/* Initialize. */
return this->Initialize(allocator, key, key_size, secure_value, 0, data_storage, fs::SubStorage(std::addressof(table_storage), node_storage_offset, node_storage_size), fs::SubStorage(std::addressof(table_storage), entry_storage_offset, entry_storage_size), header.entry_count, std::move(sw_decryptor));
R_RETURN(this->Initialize(allocator, key, key_size, secure_value, 0, data_storage, fs::SubStorage(std::addressof(table_storage), node_storage_offset, node_storage_size), fs::SubStorage(std::addressof(table_storage), entry_storage_offset, entry_storage_size), header.entry_count, std::move(sw_decryptor)));
}
Result AesCtrCounterExtendedStorage::Initialize(IAllocator *allocator, const void *key, size_t key_size, u32 secure_value, s64 counter_offset, fs::SubStorage data_storage, fs::SubStorage node_storage, fs::SubStorage entry_storage, s32 entry_count, std::unique_ptr<IDecryptor> &&decryptor) {

4
libraries/libstratosphere/source/fssystem/fssystem_aes_ctr_storage.cpp
View File

@@ -129,7 +129,7 @@ namespace ams::fssystem {
template<typename BasePointer>
Result AesCtrStorage<BasePointer>::Flush() {
return m_base_storage->Flush();
R_RETURN(m_base_storage->Flush());
}
template<typename BasePointer>
@@ -140,7 +140,7 @@ namespace ams::fssystem {
template<typename BasePointer>
Result AesCtrStorage<BasePointer>::GetSize(s64 *out) {
return m_base_storage->GetSize(out);
R_RETURN(m_base_storage->GetSize(out));
}
template<typename BasePointer>

4
libraries/libstratosphere/source/fssystem/fssystem_block_cache_buffered_storage.cpp
View File

@@ -191,7 +191,7 @@ namespace ams::fssystem {
if (!entry.is_cached) {
if (const Result result = m_data_storage->Read(entry.range.offset, src, entry.range.size); R_FAILED(result)) {
m_block_cache_manager.ReleaseCacheEntry(std::addressof(entry), range);
return this->UpdateLastResult(result);
R_RETURN(this->UpdateLastResult(result));
}
entry.is_cached = true;
}
@@ -293,7 +293,7 @@ namespace ams::fssystem {
if (!entry.is_cached && ((offset != entry.range.offset) || (offset + size < static_cast<size_t>(entry.range.GetEndOffset())))) {
if (Result result = m_data_storage->Read(entry.range.offset, dst, entry.range.size); R_FAILED(result)) {
m_block_cache_manager.ReleaseCacheEntry(std::addressof(entry), range);
return this->UpdateLastResult(result);
R_RETURN(this->UpdateLastResult(result));
}
}
entry.is_cached = true;

10
libraries/libstratosphere/source/fssystem/fssystem_bucket_tree.cpp
View File

@@ -237,7 +237,7 @@ namespace ams::fssystem {
R_TRY(visitor->Initialize(this, offsets));
return visitor->Find(virtual_address);
R_RETURN(visitor->Find(virtual_address));
}
Result BucketTree::InvalidateCache() {
@@ -429,10 +429,10 @@ namespace ams::fssystem {
PooledBuffer pool(node_size, 1);
if (node_size <= pool.GetSize()) {
return this->FindEntrySetWithBuffer(out_index, virtual_address, node_index, pool.GetBuffer());
R_RETURN(this->FindEntrySetWithBuffer(out_index, virtual_address, node_index, pool.GetBuffer()));
} else {
pool.Deallocate();
return this->FindEntrySetWithoutBuffer(out_index, virtual_address, node_index);
R_RETURN(this->FindEntrySetWithoutBuffer(out_index, virtual_address, node_index));
}
}
@@ -486,10 +486,10 @@ namespace ams::fssystem {
PooledBuffer pool(entry_set_size, 1);
if (entry_set_size <= pool.GetSize()) {
return this->FindEntryWithBuffer(virtual_address, entry_set_index, pool.GetBuffer());
R_RETURN(this->FindEntryWithBuffer(virtual_address, entry_set_index, pool.GetBuffer()));
} else {
pool.Deallocate();
return this->FindEntryWithoutBuffer(virtual_address, entry_set_index);
R_RETURN(this->FindEntryWithoutBuffer(virtual_address, entry_set_index));
}
}

6
libraries/libstratosphere/source/fssystem/fssystem_buffered_storage.cpp
View File

@@ -517,7 +517,7 @@ namespace ams::fssystem {
Result Flush() {
AMS_ASSERT(m_cache != nullptr);
return m_cache->Flush();
R_RETURN(m_cache->Flush());
}
void Invalidate() {
@@ -573,7 +573,7 @@ namespace ams::fssystem {
Result Fetch(s64 offset) {
AMS_ASSERT(m_cache != nullptr);
return m_cache->Fetch(offset);
R_RETURN(m_cache->Fetch(offset));
}
Result FetchFromBuffer(s64 offset, const void *buffer, size_t buffer_size) {
@@ -728,7 +728,7 @@ namespace ams::fssystem {
}
}
return m_base_storage.OperateRange(dst, dst_size, op_id, offset, size, src, src_size);
R_RETURN(m_base_storage.OperateRange(dst, dst_size, op_id, offset, size, src, src_size));
}
void BufferedStorage::InvalidateCaches() {

12
libraries/libstratosphere/source/fssystem/fssystem_directory_savedata_filesystem.cpp
View File

@@ -45,27 +45,27 @@ namespace ams::fssystem {
}
public:
virtual Result DoRead(size_t *out, s64 offset, void *buffer, size_t size, const fs::ReadOption &option) override {
return m_base_file->Read(out, offset, buffer, size, option);
R_RETURN(m_base_file->Read(out, offset, buffer, size, option));
}
virtual Result DoGetSize(s64 *out) override {
return m_base_file->GetSize(out);
R_RETURN(m_base_file->GetSize(out));
}
virtual Result DoFlush() override {
return m_base_file->Flush();
R_RETURN(m_base_file->Flush());
}
virtual Result DoWrite(s64 offset, const void *buffer, size_t size, const fs::WriteOption &option) override {
return m_base_file->Write(offset, buffer, size, option);
R_RETURN(m_base_file->Write(offset, buffer, size, option));
}
virtual Result DoSetSize(s64 size) override {
return m_base_file->SetSize(size);
R_RETURN(m_base_file->SetSize(size));
}
virtual Result DoOperateRange(void *dst, size_t dst_size, fs::OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) override {
return m_base_file->OperateRange(dst, dst_size, op_id, offset, size, src, src_size);
R_RETURN(m_base_file->OperateRange(dst, dst_size, op_id, offset, size, src, src_size));
}
public:
virtual sf::cmif::DomainObjectId GetDomainObjectId() const override {

4
libraries/libstratosphere/source/fssystem/fssystem_hierarchical_sha256_storage.cpp
View File

@@ -175,7 +175,7 @@ namespace ams::fssystem {
template<typename BaseStorageType>
Result HierarchicalSha256Storage<BaseStorageType>::OperateRange(void *dst, size_t dst_size, fs::OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) {
if (op_id == fs::OperationId::Invalidate) {
return m_base_storage->OperateRange(fs::OperationId::Invalidate, offset, size);
R_RETURN(m_base_storage->OperateRange(fs::OperationId::Invalidate, offset, size));
} else {
/* Succeed if zero-size. */
R_SUCCEED_IF(size == 0);
@@ -188,7 +188,7 @@ namespace ams::fssystem {
const auto reduced_size = std::min<s64>(m_base_storage_size, util::AlignUp(offset + size, m_hash_target_block_size)) - offset;
/* Operate on the base storage. */
return m_base_storage->OperateRange(dst, dst_size, op_id, offset, reduced_size, src, src_size);
R_RETURN(m_base_storage->OperateRange(dst, dst_size, op_id, offset, reduced_size, src, src_size));
}
}

4
libraries/libstratosphere/source/fssystem/fssystem_hierarchical_sha256_storage.hpp
View File

@@ -44,11 +44,11 @@ namespace ams::fssystem {
virtual Result OperateRange(void *dst, size_t dst_size, fs::OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) override;
virtual Result GetSize(s64 *out) override {
return m_base_storage->GetSize(out);
R_RETURN(m_base_storage->GetSize(out));
}
virtual Result Flush() override {
return m_base_storage->Flush();
R_RETURN(m_base_storage->Flush());
}
virtual Result SetSize(s64 size) override {

2
libraries/libstratosphere/source/fssystem/fssystem_indirect_storage.cpp
View File

@@ -30,7 +30,7 @@ namespace ams::fssystem {
const auto entry_storage_offset = node_storage_offset + node_storage_size;
/* Initialize. */
return this->Initialize(allocator, fs::SubStorage(std::addressof(table_storage), node_storage_offset, node_storage_size), fs::SubStorage(std::addressof(table_storage), entry_storage_offset, entry_storage_size), header.entry_count);
R_RETURN(this->Initialize(allocator, fs::SubStorage(std::addressof(table_storage), node_storage_offset, node_storage_size), fs::SubStorage(std::addressof(table_storage), entry_storage_offset, entry_storage_size), header.entry_count));
}
void IndirectStorage::Finalize() {

4
libraries/libstratosphere/source/fssystem/fssystem_key_slot_cache.hpp
View File

@@ -73,11 +73,11 @@ namespace ams::fssystem {
constexpr KeySlotCache() : m_mutex(), m_high_priority_mru_list(), m_low_priority_mru_list() { /* ... */ }
Result AllocateHighPriority(std::unique_ptr<KeySlotCacheAccessor> *out, const void *key, size_t key_size, s32 key2) {
return this->AllocateFromLru(out, m_high_priority_mru_list, key, key_size, key2);
R_RETURN(this->AllocateFromLru(out, m_high_priority_mru_list, key, key_size, key2));
}
Result AllocateLowPriority(std::unique_ptr<KeySlotCacheAccessor> *out, const void *key, size_t key_size, s32 key2) {
return this->AllocateFromLru(out, m_high_priority_mru_list, key, key_size, key2);
R_RETURN(this->AllocateFromLru(out, m_high_priority_mru_list, key, key_size, key2));
}
Result Find(std::unique_ptr<KeySlotCacheAccessor> *out, const void *key, size_t key_size, s32 key2) {

12
libraries/libstratosphere/source/fssystem/fssystem_memory_resource_buffer_hold_storage.hpp
View File

@@ -45,42 +45,42 @@ namespace ams::fssystem {
/* Check pre-conditions. */
AMS_ASSERT(m_storage != nullptr);
return m_storage->Read(offset, buffer, size);
R_RETURN(m_storage->Read(offset, buffer, size));
}
virtual Result OperateRange(void *dst, size_t dst_size, fs::OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) override {
/* Check pre-conditions. */
AMS_ASSERT(m_storage != nullptr);
return m_storage->OperateRange(dst, dst_size, op_id, offset, size, src, src_size);
R_RETURN(m_storage->OperateRange(dst, dst_size, op_id, offset, size, src, src_size));
}
virtual Result GetSize(s64 *out) override {
/* Check pre-conditions. */
AMS_ASSERT(m_storage != nullptr);
return m_storage->GetSize(out);
R_RETURN(m_storage->GetSize(out));
}
virtual Result Flush() override {
/* Check pre-conditions. */
AMS_ASSERT(m_storage != nullptr);
return m_storage->Flush();
R_RETURN(m_storage->Flush());
}
virtual Result Write(s64 offset, const void *buffer, size_t size) override {
/* Check pre-conditions. */
AMS_ASSERT(m_storage != nullptr);
return m_storage->Write(offset, buffer, size);
R_RETURN(m_storage->Write(offset, buffer, size));
}
virtual Result SetSize(s64 size) override {
/* Check pre-conditions. */
AMS_ASSERT(m_storage != nullptr);
return m_storage->SetSize(size);
R_RETURN(m_storage->SetSize(size));
}
};

4
libraries/libstratosphere/source/fssystem/fssystem_nca_reader.cpp
View File

@@ -392,7 +392,7 @@ namespace ams::fssystem {
AMS_ASSERT(0 <= index && index < NcaHeader::FsCountMax);
const s64 offset = sizeof(NcaHeader) + sizeof(NcaFsHeader) * index;
return m_header_storage->Read(offset, dst, sizeof(NcaFsHeader));
R_RETURN(m_header_storage->Read(offset, dst, sizeof(NcaFsHeader)));
}
bool NcaReader::GetHeaderSign1Valid() const {
@@ -506,7 +506,7 @@ namespace ams::fssystem {
AMS_ASSERT(out != nullptr);
AMS_ASSERT(this->IsInitialized());
return m_data.GetHashTargetOffset(out);
R_RETURN(m_data.GetHashTargetOffset(out));
}
bool NcaFsHeaderReader::ExistsSparseLayer() const {

2
libraries/libstratosphere/source/fssystem/fssystem_partition_file_system_meta.cpp
View File

@@ -47,7 +47,7 @@ namespace ams::fssystem {
R_UNLESS(m_buffer != nullptr, fs::ResultAllocationMemoryFailedInPartitionFileSystemMetaA());
/* Perform regular initialization. */
return this->Initialize(storage, m_buffer, m_meta_data_size);
R_RETURN(this->Initialize(storage, m_buffer, m_meta_data_size));
}
template <typename Format>

6
libraries/libstratosphere/source/fssystem/fssystem_read_only_block_cache_storage.hpp
View File

@@ -84,7 +84,7 @@ namespace ams::fssystem {
R_SUCCEED();
} else {
return m_base_storage->Read(offset, buffer, size);
R_RETURN(m_base_storage->Read(offset, buffer, size));
}
}
virtual Result OperateRange(void *dst, size_t dst_size, fs::OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) override {
@@ -106,11 +106,11 @@ namespace ams::fssystem {
}
/* Operate on the base storage. */
return m_base_storage->OperateRange(dst, dst_size, op_id, offset, size, src, src_size);
R_RETURN(m_base_storage->OperateRange(dst, dst_size, op_id, offset, size, src, src_size));
}
virtual Result GetSize(s64 *out) override {
return m_base_storage->GetSize(out);
R_RETURN(m_base_storage->GetSize(out));
}
virtual Result Flush() override {