Run clang-format on PR.

src/core/hle/kernel/address_arbiter.cpp

@@ -14,10 +14,10 @@
 #include "core/memory.h"
 
 namespace Kernel {
-    namespace AddressArbiter {
+namespace AddressArbiter {
 
-        // Performs actual address waiting logic.
+// Performs actual address waiting logic.
-        ResultCode WaitForAddress(VAddr address, s64 timeout) {
+ResultCode WaitForAddress(VAddr address, s64 timeout) {
     SharedPtr<Thread> current_thread = GetCurrentThread();
     current_thread->arb_wait_address = address;
     current_thread->status = THREADSTATUS_WAIT_ARB;
@@ -28,10 +28,10 @@ namespace Kernel {
     Core::System::GetInstance().CpuCore(current_thread->processor_id).PrepareReschedule();
     // This should never actually execute.
     return RESULT_SUCCESS;
-        }
+}
 
-        // Gets the threads waiting on an address.
+// Gets the threads waiting on an address.
-        void GetThreadsWaitingOnAddress(std::vector<SharedPtr<Thread>> &waiting_threads, VAddr address) {
+void GetThreadsWaitingOnAddress(std::vector<SharedPtr<Thread>>& waiting_threads, VAddr address) {
     auto RetrieveWaitingThreads =
         [](size_t core_index, std::vector<SharedPtr<Thread>>& waiting_threads, VAddr arb_addr) {
             const auto& scheduler = Core::System::GetInstance().Scheduler(core_index);
@@ -53,10 +53,10 @@ namespace Kernel {
               [](const SharedPtr<Thread>& lhs, const SharedPtr<Thread>& rhs) {
                   return lhs->current_priority < rhs->current_priority;
               });
-        }
+}
 
-        // Wake up num_to_wake (or all) threads in a vector.
+// Wake up num_to_wake (or all) threads in a vector.
-        void WakeThreads(std::vector<SharedPtr<Thread>> &waiting_threads, s32 num_to_wake) {
+void WakeThreads(std::vector<SharedPtr<Thread>>& waiting_threads, s32 num_to_wake) {
     // Only process up to 'target' threads, unless 'target' is <= 0, in which case process
     // them all.
     size_t last = waiting_threads.size();
@@ -71,21 +71,20 @@ namespace Kernel {
         waiting_threads[i]->arb_wait_address = 0;
         waiting_threads[i]->ResumeFromWait();
     }
+}
 
-        }
+// Signals an address being waited on.
-
+ResultCode SignalToAddress(VAddr address, s32 num_to_wake) {
-        // Signals an address being waited on.
-        ResultCode SignalToAddress(VAddr address, s32 num_to_wake) {
     // Get threads waiting on the address.
     std::vector<SharedPtr<Thread>> waiting_threads;
     GetThreadsWaitingOnAddress(waiting_threads, address);
 
     WakeThreads(waiting_threads, num_to_wake);
     return RESULT_SUCCESS;
-        }
+}
 
-        // Signals an address being waited on and increments its value if equal to the value argument.
+// Signals an address being waited on and increments its value if equal to the value argument.
-        ResultCode IncrementAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake) {
+ResultCode IncrementAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake) {
     // Ensure that we can write to the address.
     if (!Memory::IsValidVirtualAddress(address)) {
         return ERR_INVALID_ADDRESS_STATE;
@@ -98,10 +97,12 @@ namespace Kernel {
     }
 
     return SignalToAddress(address, num_to_wake);
-        }
+}
 
-        // Signals an address being waited on and modifies its value based on waiting thread count if equal to the value argument.
+// Signals an address being waited on and modifies its value based on waiting thread count if equal
-        ResultCode ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake) {
+// to the value argument.
+ResultCode ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 value,
+                                                         s32 num_to_wake) {
     // Ensure that we can write to the address.
     if (!Memory::IsValidVirtualAddress(address)) {
         return ERR_INVALID_ADDRESS_STATE;
@@ -129,10 +130,10 @@ namespace Kernel {
 
     WakeThreads(waiting_threads, num_to_wake);
     return RESULT_SUCCESS;
-        }
+}
 
-        // Waits on an address if the value passed is less than the argument value, optionally decrementing.
+// Waits on an address if the value passed is less than the argument value, optionally decrementing.
-        ResultCode WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout, bool should_decrement) {
+ResultCode WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout, bool should_decrement) {
     // Ensure that we can read the address.
     if (!Memory::IsValidVirtualAddress(address)) {
         return ERR_INVALID_ADDRESS_STATE;
@@ -150,10 +151,10 @@ namespace Kernel {
     }
 
     return WaitForAddress(address, timeout);
-        }
+}
 
-        // Waits on an address if the value passed is equal to the argument value.
+// Waits on an address if the value passed is equal to the argument value.
-        ResultCode WaitForAddressIfEqual(VAddr address, s32 value, s64 timeout) {
+ResultCode WaitForAddressIfEqual(VAddr address, s32 value, s64 timeout) {
     // Ensure that we can read the address.
     if (!Memory::IsValidVirtualAddress(address)) {
         return ERR_INVALID_ADDRESS_STATE;
@@ -168,6 +169,6 @@ namespace Kernel {
     }
 
     return WaitForAddress(address, timeout);
-        }
+}
-    } // namespace AddressArbiter
+} // namespace AddressArbiter
 } // namespace Kernel

src/core/hle/kernel/address_arbiter.h

@@ -8,25 +8,25 @@
 
 namespace Kernel {
 
-    namespace AddressArbiter {
+namespace AddressArbiter {
-        enum class ArbitrationType {
+enum class ArbitrationType {
     WaitIfLessThan = 0,
     DecrementAndWaitIfLessThan = 1,
     WaitIfEqual = 2,
-        };
+};
 
-        enum class SignalType {
+enum class SignalType {
     Signal = 0,
     IncrementAndSignalIfEqual = 1,
     ModifyByWaitingCountAndSignalIfEqual = 2,
-        };
+};
 
-        ResultCode SignalToAddress(VAddr address, s32 num_to_wake);
+ResultCode SignalToAddress(VAddr address, s32 num_to_wake);
-        ResultCode IncrementAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake);
+ResultCode IncrementAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake);
-        ResultCode ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake);
+ResultCode ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake);
 
-        ResultCode WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout, bool should_decrement);
+ResultCode WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout, bool should_decrement);
-        ResultCode WaitForAddressIfEqual(VAddr address, s32 value, s64 timeout);
+ResultCode WaitForAddressIfEqual(VAddr address, s32 value, s64 timeout);
-    } // namespace AddressArbiter
+} // namespace AddressArbiter
 
 } // namespace Kernel