Format code

Author: dancasarin

CMakeLists.txt

@@ -160,7 +160,8 @@ else ()
     if (CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)")
         set(X86 TRUE)
     endif ()
-    if (CMAKE_CXX_COMPILER_TARGET MATCHES "^([Aa][Rr][Mm]|[Aa][Aa][Rr][Cc][Hh]|[Rr][Vv][Vv])")
+    if (CMAKE_CXX_COMPILER_TARGET MATCHES
+        "^([Aa][Rr][Mm]|[Aa][Aa][Rr][Cc][Hh]|[Rr][Vv][Vv])")
         set(X86 FALSE)
     endif ()
     if (CMAKE_ANDROID_ARCH_ABI MATCHES "x86")
@@ -205,7 +206,7 @@ endif ()
 
 if (X86)
     option(KFR_ENABLE_MULTIARCH
-       "Multiple architectures will be built with runtime dispatch" ON)
+           "Multiple architectures will be built with runtime dispatch" ON)
 endif ()
 
 option(ENABLE_TESTS "Enable KFR tests" OFF)
@@ -227,8 +228,12 @@ option(KFR_INSTALL_LIBRARIES "Include libraries in installation" ON)
 option(KFR_MANAGED_ALLOCATION
        "Use KFR managed memory (copy-free aligned reallocation, ref counting)"
        OFF)
-option(KFR_USE_BOOST_MATH "Use Boost.Math (standalone) to support Elliptic filters" ON)
-option(KFR_USE_BOOST "Use Boost to support Elliptic filters. Enable this only if you're already using Boost" OFF)
+option(KFR_USE_BOOST_MATH
+       "Use Boost.Math (standalone) to support Elliptic filters" ON)
+option(
+    KFR_USE_BOOST
+    "Use Boost to support Elliptic filters. Enable this only if you're already using Boost"
+    OFF)
 option(KFR_USE_STD_FILESYSTEM "Use std::filesystem for path arguments" OFF)
 mark_as_advanced(KFR_ENABLE_ASMTEST)
 mark_as_advanced(KFR_REGENERATE_TESTS)
@@ -273,7 +278,10 @@ endif ()
 
 if (NOT X86)
     if (KFR_ARCH IN_LIST DETECT_NAMES)
-        message(STATUS "Cpu detection is disabled on non-x86, setting neon (KFR_ARCH=${KFR_ARCH})")
+        message(
+            STATUS
+                "Cpu detection is disabled on non-x86, setting neon (KFR_ARCH=${KFR_ARCH})"
+        )
         if (BITNESS64)
             set(KFR_ARCH neon64)
         else ()
@@ -291,8 +299,7 @@ if (KFR_ARCH IN_LIST DETECT_NAMES AND NOT CMAKE_CROSSCOMPILING)
         ${CMAKE_CURRENT_SOURCE_DIR}/cmake/detect_cpu.cpp
         CMAKE_FLAGS
             "-DINCLUDE_DIRECTORIES=${CMAKE_CURRENT_SOURCE_DIR}/include"
-            -DCMAKE_CXX_STANDARD=20
-            -DCMAKE_CXX_STANDARD_REQUIRED=ON
+            -DCMAKE_CXX_STANDARD=20 -DCMAKE_CXX_STANDARD_REQUIRED=ON
             "-DCOMPILE_DEFINITIONS=-DCPU_${KFR_ARCH}=1"
         COMPILE_OUTPUT_VARIABLE COMPILE_OUT
         RUN_OUTPUT_VARIABLE RUN_OUT)
@@ -400,7 +407,8 @@ else ()
     target_link_libraries(kfr INTERFACE ${STD_LIB} ${PTHREAD_LIB} m)
 endif ()
 if (KFR_DISABLE_CLANG_EXTENSIONS)
-    target_compile_definitions(kfr INTERFACE $<BUILD_INTERFACE:KFR_DISABLE_CLANG_EXT>)
+    target_compile_definitions(
+        kfr INTERFACE $<BUILD_INTERFACE:KFR_DISABLE_CLANG_EXT>)
 endif ()
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     add_compile_options(-Wno-ignored-qualifiers -Wno-psabi)
@@ -419,11 +427,13 @@ if (NOT KFR_ENABLE_DFT)
     target_compile_definitions(kfr INTERFACE $<BUILD_INTERFACE:KFR_NO_DFT>)
 endif ()
 if (KFR_EXTENDED_TESTS)
-    target_compile_definitions(kfr INTERFACE $<BUILD_INTERFACE:KFR_EXTENDED_TESTS>)
+    target_compile_definitions(kfr
+                               INTERFACE $<BUILD_INTERFACE:KFR_EXTENDED_TESTS>)
 endif ()
 
 if (KFR_MANAGED_ALLOCATION)
-    target_compile_definitions(kfr INTERFACE $<BUILD_INTERFACE:KFR_MANAGED_ALLOCATION=1>)
+    target_compile_definitions(
+        kfr INTERFACE $<BUILD_INTERFACE:KFR_MANAGED_ALLOCATION=1>)
 endif ()
 
 set(KFR_DEBUG_INSTALL_SUFFIX
@@ -513,9 +523,8 @@ set(KFR_INSTALL_CMAKEDIR
     "${CMAKE_INSTALL_LIBDIR}/cmake/kfr"
     CACHE STRING "Path to KFR CMake files")
 
-install(FILES 
-    ${CMAKE_CURRENT_BINARY_DIR}/KFRConfigVersion.cmake
-    DESTINATION ${KFR_INSTALL_CMAKEDIR})
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/KFRConfigVersion.cmake
+        DESTINATION ${KFR_INSTALL_CMAKEDIR})
 
 configure_package_config_file(
     ${CMAKE_CURRENT_LIST_DIR}/cmake/config.cmake.in
@@ -524,7 +533,8 @@ configure_package_config_file(
 
 install(TARGETS kfr EXPORT KFRTargets)
 
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/KFRConfig.cmake DESTINATION "${KFR_INSTALL_CMAKEDIR}")
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/KFRConfig.cmake
+        DESTINATION "${KFR_INSTALL_CMAKEDIR}")
 
 install(
     EXPORT KFRTargets

cmake/aarch64.cmake

@@ -3,7 +3,9 @@ set(CMAKE_SYSTEM_NAME Linux)
 set(CMAKE_SYSTEM_PROCESSOR aarch64)
 
 set(EMULATOR qemu-aarch64)
-set(QEMU_LD_PREFIX "/usr/aarch64-linux-gnu/" CACHE INTERNAL "")
+set(QEMU_LD_PREFIX
+    "/usr/aarch64-linux-gnu/"
+    CACHE INTERNAL "")
 list(APPEND EMULATOR "-L")
 list(APPEND EMULATOR ${QEMU_LD_PREFIX})
 
@@ -18,8 +20,12 @@ set(CMAKE_OBJDUMP llvm-objdump)
 set(CMAKE_RANLIB llvm-ranlib)
 
 # Set compiler flags for AArch64
-set(CMAKE_C_FLAGS "--target=aarch64-linux-gnu -mcpu=cortex-a72" CACHE STRING "C flags")
-set(CMAKE_CXX_FLAGS "--target=aarch64-linux-gnu -mcpu=cortex-a72" CACHE STRING "C++ flags")
+set(CMAKE_C_FLAGS
+    "--target=aarch64-linux-gnu -mcpu=cortex-a72"
+    CACHE STRING "C flags")
+set(CMAKE_CXX_FLAGS
+    "--target=aarch64-linux-gnu -mcpu=cortex-a72"
+    CACHE STRING "C++ flags")
 
 # Set the target environment path
 set(CMAKE_FIND_ROOT_PATH /usr/aarch64-linux-gnu)

cmake/add_kfr_library.cmake

@@ -26,17 +26,20 @@ function (add_kfr_library)
             target_link_libraries(${LIB_NAME} INTERFACE ${LIB_NAME}_${ARCH})
             target_set_arch(${LIB_NAME}_${ARCH} PRIVATE ${ARCH})
             if (NOT ARCH STREQUAL BASE_ARCH)
-                target_compile_definitions(${LIB_NAME}_${ARCH} PRIVATE KFR_SKIP_IF_NON_X86=1)
+                target_compile_definitions(${LIB_NAME}_${ARCH}
+                                           PRIVATE KFR_SKIP_IF_NON_X86=1)
             endif ()
         endforeach ()
         target_compile_definitions(${LIB_NAME}_${BASE_ARCH}
                                    PRIVATE KFR_BASE_ARCH=1)
-        set_target_properties(${LIB_NAME}_${BASE_ARCH} PROPERTIES OUTPUT_NAME ${LIB_NAME})
+        set_target_properties(${LIB_NAME}_${BASE_ARCH} PROPERTIES OUTPUT_NAME
+                                                                  ${LIB_NAME})
 
         link_as_whole(${LIB_NAME} INTERFACE ${LIB_NAME}_${BASE_ARCH})
 
         list(APPEND ${LIB_NAME}_TARGETS ${LIB_NAME})
-        target_compile_definitions(${LIB_NAME} INTERFACE $<BUILD_INTERFACE:${LIB_PUBLIC_DEFINITIONS}>)
+        target_compile_definitions(
+            ${LIB_NAME} INTERFACE $<BUILD_INTERFACE:${LIB_PUBLIC_DEFINITIONS}>)
     else ()
         add_library(${LIB_NAME} STATIC ${LIB_SOURCES})
         list(APPEND ${LIB_NAME}_LIBS ${LIB_NAME})
@@ -49,11 +52,11 @@ function (add_kfr_library)
         target_link_libraries(${LIB} PRIVATE ${LIB_LIBRARIES})
         target_link_libraries(${LIB} PUBLIC ${LIB_PUBLIC_LIBRARIES})
         target_compile_definitions(${LIB} PRIVATE ${LIB_DEFINITIONS})
-        target_compile_definitions(${LIB} PUBLIC $<BUILD_INTERFACE:${LIB_PUBLIC_DEFINITIONS}>)
+        target_compile_definitions(
+            ${LIB} PUBLIC $<BUILD_INTERFACE:${LIB_PUBLIC_DEFINITIONS}>)
         target_compile_options(${LIB} PRIVATE ${LIB_OPTIONS})
         target_include_directories(${LIB} PRIVATE ${LIB_INCLUDE_DIRECTORIES})
     endforeach ()
-    
 
     set(${LIB_NAME}_LIBS
         ${${LIB_NAME}_LIBS}

cmake/arm.cmake

@@ -3,7 +3,9 @@ set(CMAKE_SYSTEM_NAME Linux)
 set(CMAKE_SYSTEM_PROCESSOR arm)
 
 set(EMULATOR qemu-arm)
-set(QEMU_LD_PREFIX "/usr/arm-linux-gnueabihf/" CACHE INTERNAL "")
+set(QEMU_LD_PREFIX
+    "/usr/arm-linux-gnueabihf/"
+    CACHE INTERNAL "")
 list(APPEND EMULATOR "-L")
 list(APPEND EMULATOR ${QEMU_LD_PREFIX})
 
@@ -18,8 +20,12 @@ set(CMAKE_OBJDUMP llvm-objdump)
 set(CMAKE_RANLIB llvm-ranlib)
 
 # Set compiler flags for ARM
-set(CMAKE_C_FLAGS "--target=arm-linux-gnueabihf -mcpu=cortex-a15 -mfpu=neon-vfpv4 -mfloat-abi=hard" CACHE STRING "C flags")
-set(CMAKE_CXX_FLAGS "--target=arm-linux-gnueabihf -mcpu=cortex-a15 -mfpu=neon-vfpv4 -mfloat-abi=hard" CACHE STRING "C++ flags")
+set(CMAKE_C_FLAGS
+    "--target=arm-linux-gnueabihf -mcpu=cortex-a15 -mfpu=neon-vfpv4 -mfloat-abi=hard"
+    CACHE STRING "C flags")
+set(CMAKE_CXX_FLAGS
+    "--target=arm-linux-gnueabihf -mcpu=cortex-a15 -mfpu=neon-vfpv4 -mfloat-abi=hard"
+    CACHE STRING "C++ flags")
 
 # Set the target environment path
 set(CMAKE_FIND_ROOT_PATH /usr/arm-linux-gnueabihf)

cmake/link_as_whole.cmake

@@ -1,11 +1,15 @@
-
 function (link_as_whole TARGET TYPE LIBRARY)
     if (APPLE)
-        target_link_options(${TARGET} ${TYPE} "LINKER:-force_load,$<TARGET_FILE:${LIBRARY}>")
+        target_link_options(${TARGET} ${TYPE}
+                            "LINKER:-force_load,$<TARGET_FILE:${LIBRARY}>")
     elseif (MSVC)
         target_link_options(${TARGET} ${TYPE}
                             /WHOLEARCHIVE:$<TARGET_FILE:${LIBRARY}>)
     else ()
-        target_link_options(${TARGET} ${TYPE} "LINKER:--push-state,--whole-archive,$<TARGET_FILE:${LIBRARY}>,--pop-state")
+        target_link_options(
+            ${TARGET}
+            ${TYPE}
+            "LINKER:--push-state,--whole-archive,$<TARGET_FILE:${LIBRARY}>,--pop-state"
+        )
     endif ()
 endfunction ()

cmake/macos-merge-binaries.cmake

@@ -63,7 +63,8 @@ endfunction ()
 
 # Function to compare two files for equality
 function (compare_files file1 file2 are_equal_var)
-    execute_process(COMMAND cmp -s "${file1}" "${file2}" RESULT_VARIABLE cmp_result)
+    execute_process(COMMAND cmp -s "${file1}" "${file2}"
+                    RESULT_VARIABLE cmp_result)
     if (cmp_result EQUAL 0)
         set(${are_equal_var}
             TRUE
@@ -114,43 +115,66 @@ function (merge_file arm64_file x64_file output_file)
 
     # Ensure both files are either Mach-O/static lib or neither
     if (is_arm64_macho AND NOT is_x64_macho)
-        message(FATAL_ERROR "File type mismatch: ${arm64_file} is Mach-O/static lib, but ${x64_file} is not")
+        message(
+            FATAL_ERROR
+                "File type mismatch: ${arm64_file} is Mach-O/static lib, but ${x64_file} is not"
+        )
     endif ()
     if (NOT is_arm64_macho AND is_x64_macho)
-        message(FATAL_ERROR "File type mismatch: ${x64_file} is Mach-O/static lib, but ${arm64_file} is not")
+        message(
+            FATAL_ERROR
+                "File type mismatch: ${x64_file} is Mach-O/static lib, but ${arm64_file} is not"
+        )
     endif ()
 
     if (is_arm64_macho AND is_x64_macho)
         # Run lipo to create fat binary
-        execute_process(COMMAND "${LIPO}" -create "${arm64_file}" "${x64_file}" -output "${output_file}"
-                        RESULT_VARIABLE lipo_result)
+        execute_process(
+            COMMAND "${LIPO}" -create "${arm64_file}" "${x64_file}" -output
+                    "${output_file}" RESULT_VARIABLE lipo_result)
         if (NOT lipo_result EQUAL 0)
-            message(FATAL_ERROR "Failed to merge ${arm64_file} and ${x64_file} with lipo")
+            message(
+                FATAL_ERROR
+                    "Failed to merge ${arm64_file} and ${x64_file} with lipo")
         endif ()
-        message(STATUS "Merged ${arm64_file} and ${x64_file} into ${output_file}")
+        message(
+            STATUS "Merged ${arm64_file} and ${x64_file} into ${output_file}")
     else ()
         # Check for preference lists
         file_matches_preference("${arm64_file}" "${PREFER_X64}" prefer_x64)
         file_matches_preference("${arm64_file}" "${PREFER_ARM64}" prefer_arm64)
 
         if (prefer_x64 AND prefer_arm64)
-            message(FATAL_ERROR "File ${arm64_file} matches both PREFER_X64 and PREFER_ARM64 lists")
+            message(
+                FATAL_ERROR
+                    "File ${arm64_file} matches both PREFER_X64 and PREFER_ARM64 lists"
+            )
         elseif (prefer_x64)
             file(COPY_FILE "${x64_file}" "${output_file}")
-            message(STATUS "Copied ${x64_file} to ${output_file} (PREFER_X64 match)")
+            message(
+                STATUS "Copied ${x64_file} to ${output_file} (PREFER_X64 match)"
+            )
         elseif (prefer_arm64)
             file(COPY_FILE "${arm64_file}" "${output_file}")
-            message(STATUS "Copied ${arm64_file} to ${output_file} (PREFER_ARM64 match)")
+            message(
+                STATUS
+                    "Copied ${arm64_file} to ${output_file} (PREFER_ARM64 match)"
+            )
         else ()
             # Compare files if not Mach-O or static library and no preference
             compare_files("${arm64_file}" "${x64_file}" files_equal)
             if (NOT files_equal)
                 message(
-                    FATAL_ERROR "Non-Mach-O files differ: ${arm64_file} and ${x64_file}\nDiff output:\n${DIFF_OUTPUT}")
+                    FATAL_ERROR
+                        "Non-Mach-O files differ: ${arm64_file} and ${x64_file}\nDiff output:\n${DIFF_OUTPUT}"
+                )
             endif ()
             # Copy x64 file
             file(COPY_FILE "${x64_file}" "${output_file}")
-            message(STATUS "Copied ${x64_file} to ${output_file} (non-Mach-O or non-static library)")
+            message(
+                STATUS
+                    "Copied ${x64_file} to ${output_file} (non-Mach-O or non-static library)"
+            )
         endif ()
     endif ()
 endfunction ()
@@ -198,7 +222,10 @@ function (process_directory arm64_base x64_base output_base)
         # Clean up temporary files
         file(REMOVE "${temp_arm64_list}" "${temp_x64_list}")
 
-        message(FATAL_ERROR "Directories have different sets of files. Diff output:\n${diff_output}")
+        message(
+            FATAL_ERROR
+                "Directories have different sets of files. Diff output:\n${diff_output}"
+        )
     endif ()
 
     foreach (item ${arm64_items})