Ran cmake-format

Cleaning up the accrual of non-standard formatting.

Author: StableCoder

c-standards.cmake

@@ -46,4 +46,4 @@ macro(c_23)
   set(CMAKE_C_STANDARD 23)
   set(CMAKE_C_STANDARD_REQUIRED ON)
   set(CMAKE_C_EXTENSIONS OFF)
-endmacro()
+endmacro()

code-coverage.cmake

@@ -493,7 +493,7 @@ function(add_code_coverage)
       add_compile_options(-fprofile-instr-generate -fcoverage-mapping)
       add_link_options(-fprofile-instr-generate -fcoverage-mapping)
     elseif(CMAKE_C_COMPILER_ID MATCHES "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES
-                                              "GNU")
+                                                "GNU")
       add_compile_options(-fprofile-arcs -ftest-coverage)
       link_libraries(gcov)
     endif()

sanitizers.cmake

@@ -31,14 +31,14 @@ function(append value)
 endfunction()
 
 function(test_san_flags return_var flags)
-    set(QUIET_BACKUP ${CMAKE_REQUIRED_QUIET})
-    set(CMAKE_REQUIRED_QUIET TRUE)
-    unset(${return_var} CACHE)
-    set(FLAGS_BACKUP ${CMAKE_REQUIRED_FLAGS})
-    set(CMAKE_REQUIRED_FLAGS "${flags}")
-    check_cxx_source_compiles("int main() { return 0; }" ${return_var})
-    set(CMAKE_REQUIRED_FLAGS "${FLAGS_BACKUP}")
-    set(CMAKE_REQUIRED_QUIET "${QUIET_BACKUP}")
+  set(QUIET_BACKUP ${CMAKE_REQUIRED_QUIET})
+  set(CMAKE_REQUIRED_QUIET TRUE)
+  unset(${return_var} CACHE)
+  set(FLAGS_BACKUP ${CMAKE_REQUIRED_FLAGS})
+  set(CMAKE_REQUIRED_FLAGS "${flags}")
+  check_cxx_source_compiles("int main() { return 0; }" ${return_var})
+  set(CMAKE_REQUIRED_FLAGS "${FLAGS_BACKUP}")
+  set(CMAKE_REQUIRED_QUIET "${QUIET_BACKUP}")
 endfunction()
 
 if(USE_SANITIZER)
@@ -57,11 +57,13 @@ if(USE_SANITIZER)
       message(STATUS "Testing with Address sanitizer")
       set(SANITIZER_ADDR_FLAG "-fsanitize=address")
       test_san_flags(SANITIZER_ADDR_AVAILABLE ${SANITIZER_ADDR_FLAG})
-      if (SANITIZER_ADDR_AVAILABLE)
+      if(SANITIZER_ADDR_AVAILABLE)
         message(STATUS "  Building with Address sanitizer")
         append("${SANITIZER_ADDR_FLAG}" SANITIZER_SELECTED_FLAGS)
       else()
-        message(FATAL_ERROR "Address sanitizer not available for ${CMAKE_CXX_COMPILER}")
+        message(
+          FATAL_ERROR
+            "Address sanitizer not available for ${CMAKE_CXX_COMPILER}")
       endif()
     endif()
 
@@ -75,15 +77,18 @@ if(USE_SANITIZER)
         message(STATUS "Testing with Memory sanitizer")
       endif()
       test_san_flags(SANITIZER_MEM_AVAILABLE ${SANITIZER_MEM_FLAG})
-      if (SANITIZER_MEM_AVAILABLE)
+      if(SANITIZER_MEM_AVAILABLE)
         if(USE_SANITIZER MATCHES "([Mm]emory[Ww]ith[Oo]rigins)")
-            message(STATUS "  Building with MemoryWithOrigins sanitizer")
+          message(STATUS "  Building with MemoryWithOrigins sanitizer")
         else()
-            message(STATUS "  Building with Memory sanitizer")
+          message(STATUS "  Building with Memory sanitizer")
         endif()
         append("${SANITIZER_MEM_FLAG}" SANITIZER_SELECTED_FLAGS)
       else()
-        message(FATAL_ERROR "Memory [With Origins] sanitizer not available for ${CMAKE_CXX_COMPILER}")
+        message(
+          FATAL_ERROR
+            "Memory [With Origins] sanitizer not available for ${CMAKE_CXX_COMPILER}"
+        )
       endif()
     endif()
 
@@ -94,57 +99,69 @@ if(USE_SANITIZER)
         append("-fsanitize-blacklist=${BLACKLIST_FILE}" SANITIZER_UB_FLAG)
       endif()
       test_san_flags(SANITIZER_UB_AVAILABLE ${SANITIZER_UB_FLAG})
-      if (SANITIZER_UB_AVAILABLE)
+      if(SANITIZER_UB_AVAILABLE)
         message(STATUS "  Building with Undefined Behaviour sanitizer")
         append("${SANITIZER_UB_FLAG}" SANITIZER_SELECTED_FLAGS)
       else()
-        message(FATAL_ERROR "Undefined Behaviour sanitizer not available for ${CMAKE_CXX_COMPILER}")
+        message(
+          FATAL_ERROR
+            "Undefined Behaviour sanitizer not available for ${CMAKE_CXX_COMPILER}"
+        )
       endif()
     endif()
 
     if(USE_SANITIZER MATCHES "([Tt]hread)")
       message(STATUS "Testing with Thread sanitizer")
       set(SANITIZER_THREAD_FLAG "-fsanitize=thread")
       test_san_flags(SANITIZER_THREAD_AVAILABLE ${SANITIZER_THREAD_FLAG})
-      if (SANITIZER_THREAD_AVAILABLE)
+      if(SANITIZER_THREAD_AVAILABLE)
         message(STATUS "  Building with Thread sanitizer")
         append("${SANITIZER_THREAD_FLAG}" SANITIZER_SELECTED_FLAGS)
       else()
-        message(FATAL_ERROR "Thread sanitizer not available for ${CMAKE_CXX_COMPILER}")
+        message(
+          FATAL_ERROR "Thread sanitizer not available for ${CMAKE_CXX_COMPILER}"
+        )
       endif()
     endif()
 
     if(USE_SANITIZER MATCHES "([Ll]eak)")
       message(STATUS "Testing with Leak sanitizer")
       set(SANITIZER_LEAK_FLAG "-fsanitize=leak")
       test_san_flags(SANITIZER_LEAK_AVAILABLE ${SANITIZER_LEAK_FLAG})
-      if (SANITIZER_LEAK_AVAILABLE)
+      if(SANITIZER_LEAK_AVAILABLE)
         message(STATUS "  Building with Leak sanitizer")
         append("${SANITIZER_LEAK_FLAG}" SANITIZER_SELECTED_FLAGS)
       else()
-        message(FATAL_ERROR "Thread sanitizer not available for ${CMAKE_CXX_COMPILER}")
+        message(
+          FATAL_ERROR "Thread sanitizer not available for ${CMAKE_CXX_COMPILER}"
+        )
       endif()
     endif()
 
     if(USE_SANITIZER MATCHES "([Cc][Ff][Ii])")
       message(STATUS "Testing with Control Flow Integrity(CFI) sanitizer")
       set(SANITIZER_CFI_FLAG "-fsanitize=cfi")
       test_san_flags(SANITIZER_CFI_AVAILABLE ${SANITIZER_CFI_FLAG})
-      if (SANITIZER_CFI_AVAILABLE)
+      if(SANITIZER_CFI_AVAILABLE)
         message(STATUS "  Building with Control Flow Integrity(CFI) sanitizer")
         append("${SANITIZER_LEAK_FLAG}" SANITIZER_SELECTED_FLAGS)
       else()
-        message(FATAL_ERROR "Control Flow Integrity(CFI) sanitizer not available for ${CMAKE_CXX_COMPILER}")
+        message(
+          FATAL_ERROR
+            "Control Flow Integrity(CFI) sanitizer not available for ${CMAKE_CXX_COMPILER}"
+        )
       endif()
     endif()
 
     message(STATUS "Sanitizer flags: ${SANITIZER_SELECTED_FLAGS}")
     test_san_flags(SANITIZER_SELECTED_COMPATIBLE ${SANITIZER_SELECTED_FLAGS})
-    if (SANITIZER_SELECTED_COMPATIBLE)
+    if(SANITIZER_SELECTED_COMPATIBLE)
       message(STATUS " Building with ${SANITIZER_SELECTED_FLAGS}")
       append("${SANITIZER_SELECTED_FLAGS}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
     else()
-      message(FATAL_ERROR " Sanitizer flags ${SANITIZER_SELECTED_FLAGS} are not compatible.")
+      message(
+        FATAL_ERROR
+          " Sanitizer flags ${SANITIZER_SELECTED_FLAGS} are not compatible.")
     endif()
   elseif(MSVC)
     if(USE_SANITIZER MATCHES "([Aa]ddress)")