Address clang-format issues.

src/citra/citra.cpp

@@ -126,13 +126,13 @@ int main(int argc, char** argv) {
     Settings::values.use_gdbstub = use_gdbstub;
     Settings::Apply();
 
-    std::unique_ptr<EmuWindow_SDL2> emu_window{ std::make_unique<EmuWindow_SDL2>() };
+    std::unique_ptr<EmuWindow_SDL2> emu_window{std::make_unique<EmuWindow_SDL2>()};
 
-    Core::System& system{ Core::System::GetInstance() };
+    Core::System& system{Core::System::GetInstance()};
 
     SCOPE_EXIT({ system.Shutdown(); });
 
-    const Core::System::ResultStatus load_result{ system.Load(emu_window.get(), filepath) };
+    const Core::System::ResultStatus load_result{system.Load(emu_window.get(), filepath)};
 
     switch (load_result) {
     case Core::System::ResultStatus::ErrorGetLoader:

src/citra_qt/main.cpp

@@ -289,9 +289,9 @@ bool GMainWindow::LoadROM(const std::string& filename) {
         return false;
     }
 
-    Core::System& system{ Core::System::GetInstance() };
+    Core::System& system{Core::System::GetInstance()};
 
-    const Core::System::ResultStatus result{ system.Load(render_window, filename) };
+    const Core::System::ResultStatus result{system.Load(render_window, filename)};
 
     if (result != Core::System::ResultStatus::Success) {
         switch (result) {
@@ -307,8 +307,7 @@ bool GMainWindow::LoadROM(const std::string& filename) {
                                   tr("Could not determine the system mode."));
             break;
 
-        case Core::System::ResultStatus::ErrorLoader_ErrorEncrypted:
-        {
+        case Core::System::ResultStatus::ErrorLoader_ErrorEncrypted: {
             // Build the MessageBox ourselves to have clickable link
             QMessageBox popup_error;
             popup_error.setTextFormat(Qt::RichText);

src/core/core.cpp

@@ -78,20 +78,20 @@ System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& file
         return ResultStatus::ErrorGetLoader;
     }
 
-    boost::optional<u32> system_mode{ app_loader->LoadKernelSystemMode() };
+    boost::optional<u32> system_mode{app_loader->LoadKernelSystemMode()};
     if (!system_mode) {
         LOG_CRITICAL(Core, "Failed to determine system mode!");
         return ResultStatus::ErrorSystemMode;
     }
 
-    ResultStatus init_result{ Init(emu_window, system_mode.get()) };
+    ResultStatus init_result{Init(emu_window, system_mode.get())};
     if (init_result != ResultStatus::Success) {
         LOG_CRITICAL(Core, "Failed to initialize system (Error %i)!", init_result);
         System::Shutdown();
         return init_result;
     }
 
-    const Loader::ResultStatus load_result{ app_loader->Load() };
+    const Loader::ResultStatus load_result{app_loader->Load()};
     if (Loader::ResultStatus::Success != load_result) {
         LOG_CRITICAL(Core, "Failed to load ROM (Error %i)!", load_result);
         System::Shutdown();

src/core/core.h

@@ -48,17 +48,18 @@ public:
         ErrorSystemMode,            ///< Error determining the system mode
         ErrorLoader,                ///< Error loading the specified application
         ErrorLoader_ErrorEncrypted, ///< Error loading the specified application due to encryption
-        ErrorLoader_ErrorInvalidFormat, ///< Error loading the specified application due to an invalid format
+        ErrorLoader_ErrorInvalidFormat, ///< Error loading the specified application due to an
+                                        /// invalid format
         ErrorVideoCore,                 ///< Error in the video core
     };
 
     /**
      * Run the core CPU loop
-     * This function runs the core for the specified number of CPU instructions before trying to update
-     * hardware. This is much faster than SingleStep (and should be equivalent), as the CPU is not
-     * required to do a full dispatch with each instruction. NOTE: the number of instructions requested
-     * is not guaranteed to run, as this will be interrupted preemptively if a hardware update is
-     * requested (e.g. on a thread switch).
+     * This function runs the core for the specified number of CPU instructions before trying to
+     * update hardware. This is much faster than SingleStep (and should be equivalent), as the CPU
+     * is not required to do a full dispatch with each instruction. NOTE: the number of instructions
+     * requested is not guaranteed to run, as this will be interrupted preemptively if a hardware
+     * update is requested (e.g. on a thread switch).
      * @param tight_loop Number of instructions to execute.
      * @return Result status, indicating whethor or not the operation succeeded.
      */

src/core/file_sys/archive_extsavedata.cpp

@@ -141,11 +141,10 @@ std::string GetExtSaveDataPath(const std::string& mount_point, const Path& path)
 
 std::string GetExtDataContainerPath(const std::string& mount_point, bool shared) {
     if (shared)
-        return Common::StringFromFormat("%sdata/%s/extdata/", mount_point.c_str(),
-                                        SYSTEM_ID);
+        return Common::StringFromFormat("%sdata/%s/extdata/", mount_point.c_str(), SYSTEM_ID);
 
-    return Common::StringFromFormat("%sNintendo 3DS/%s/%s/extdata/", mount_point.c_str(),
-                                    SYSTEM_ID, SDCARD_ID);
+    return Common::StringFromFormat("%sNintendo 3DS/%s/%s/extdata/", mount_point.c_str(), SYSTEM_ID,
+                                    SDCARD_ID);
 }
 
 Path ConstructExtDataBinaryPath(u32 media_type, u32 high, u32 low) {

src/core/gdbstub/gdbstub.cpp

@@ -30,12 +30,12 @@
 #include <unistd.h>
 #endif
 
-#include "core/loader/loader.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
 #include "core/gdbstub/gdbstub.h"
+#include "core/loader/loader.h"
 #include "core/memory.h"
 
 const int GDB_BUFFER_SIZE = 10000;

src/core/hle/service/fs/archive.h

@@ -17,9 +17,9 @@ class FileBackend;
 }
 
 /// The unique system identifier hash, also known as ID0
-static constexpr char SYSTEM_ID[]{ "00000000000000000000000000000000" };
+static constexpr char SYSTEM_ID[]{"00000000000000000000000000000000"};
 /// The scrambled SD card CID, also known as ID1
-static constexpr char SDCARD_ID[]{ "00000000000000000000000000000000" };
+static constexpr char SDCARD_ID[]{"00000000000000000000000000000000"};
 
 namespace Service {
 namespace FS {

src/core/hle/svc.cpp

@@ -166,7 +166,8 @@ static ResultCode ControlMemory(u32* out_addr, u32 operation, u32 addr0, u32 add
 }
 
 /// Maps a memory block to specified address
-static ResultCode MapMemoryBlock(Kernel::Handle handle, u32 addr, u32 permissions, u32 other_permissions) {
+static ResultCode MapMemoryBlock(Kernel::Handle handle, u32 addr, u32 permissions,
+                                 u32 other_permissions) {
     using Kernel::SharedMemory;
     using Kernel::MemoryPermission;
 
@@ -295,8 +296,8 @@ static ResultCode WaitSynchronization1(Kernel::Handle handle, s64 nano_seconds)
 }
 
 /// Wait for the given handles to synchronize, timeout after the specified nanoseconds
-static ResultCode WaitSynchronizationN(s32* out, Kernel::Handle* handles, s32 handle_count, bool wait_all,
-                                       s64 nano_seconds) {
+static ResultCode WaitSynchronizationN(s32* out, Kernel::Handle* handles, s32 handle_count,
+                                       bool wait_all, s64 nano_seconds) {
     Kernel::Thread* thread = Kernel::GetCurrentThread();
 
     // Check if 'handles' is invalid
@@ -507,8 +508,8 @@ static ResultCode GetResourceLimitCurrentValues(s64* values, Kernel::Handle reso
 }
 
 /// Get resource limit max values
-static ResultCode GetResourceLimitLimitValues(s64* values, Kernel::Handle resource_limit_handle, u32* names,
-                                              u32 name_count) {
+static ResultCode GetResourceLimitLimitValues(s64* values, Kernel::Handle resource_limit_handle,
+                                              u32* names, u32 name_count) {
     LOG_TRACE(Kernel_SVC, "called resource_limit=%08X, names=%p, name_count=%d",
               resource_limit_handle, names, name_count);
 
@@ -860,8 +861,8 @@ static s64 GetSystemTick() {
 }
 
 /// Creates a memory block at the specified address with the specified permissions and size
-static ResultCode CreateMemoryBlock(Kernel::Handle* out_handle, u32 addr, u32 size, u32 my_permission,
-                                    u32 other_permission) {
+static ResultCode CreateMemoryBlock(Kernel::Handle* out_handle, u32 addr, u32 size,
+                                    u32 my_permission, u32 other_permission) {
     using Kernel::SharedMemory;
 
     if (size % Memory::PAGE_SIZE != 0)
@@ -912,8 +913,8 @@ static ResultCode CreateMemoryBlock(Kernel::Handle* out_handle, u32 addr, u32 si
     return RESULT_SUCCESS;
 }
 
-static ResultCode CreatePort(Kernel::Handle* server_port, Kernel::Handle* client_port, const char* name,
-                             u32 max_sessions) {
+static ResultCode CreatePort(Kernel::Handle* server_port, Kernel::Handle* client_port,
+                             const char* name, u32 max_sessions) {
     // TODO(Subv): Implement named ports.
     ASSERT_MSG(name == nullptr, "Named ports are currently unimplemented");