From 6889de2da71b813dfa7d1fd0d6c6fa82116212c8 Mon Sep 17 00:00:00 2001
From: David A Minton <daminton@purdue.edu>
Date: Sun, 17 Sep 2023 22:25:29 -0400
Subject: [PATCH] Added C flags to the compiler flags so that the cython code
 can get debugging flags

---
 CMakeLists.txt                                |   5 +
 buildscripts/install_editable_debug.sh        |  15 +
 ...tranFlags.cmake => SetSwiftestFlags.cmake} | 264 +++++++++---------
 src/CMakeLists.txt                            |   7 -
 4 files changed, 145 insertions(+), 146 deletions(-)
 create mode 100755 buildscripts/install_editable_debug.sh
 rename cmake/Modules/{SetFortranFlags.cmake => SetSwiftestFlags.cmake} (82%)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6451c20da..da029328d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -91,6 +91,11 @@ FILE(TO_CMAKE_PATH ${PY} PY)
 # Set the name of the swiftest library
 SET(SWIFTEST_LIBRARY ${SKBUILD_PROJECT_NAME})
 
+
+# This INCLUDE statement executes code that sets the compile flags for DEBUG,
+# RELEASE, PROFILING, and TESTING.  
+INCLUDE(SetSwiftestFlags) 
+
 # The source for the SWIFTEST binary and have it placed in the bin folder
 ADD_SUBDIRECTORY(${SRC} ${CMAKE_INSTALL_BINDIR})
 ADD_SUBDIRECTORY(${PY})
diff --git a/buildscripts/install_editable_debug.sh b/buildscripts/install_editable_debug.sh
new file mode 100755
index 000000000..29c606257
--- /dev/null
+++ b/buildscripts/install_editable_debug.sh
@@ -0,0 +1,15 @@
+#!/bin/zsh
+# installs an editable (local) package in debug mode
+set -a
+SCRIPT_DIR=$(realpath $(dirname $0))
+ROOT_DIR=$(realpath ${SCRIPT_DIR}/..)
+cd ${ROOT_DIR}
+python3 -m pip install --upgrade pip --user
+pip install scikit-build-core pyproject-metadata pathspec ninja --user
+pip install --config-settings=editable.rebuild=true \
+            --config-settings=build-dir="build/{wheel_tag}" \
+            --config-settings=cmake.build-type="Debug" \
+            --config-settings=cmake.args="-DUSE_SIMD=ON" \
+            --config-settings=cmake.args="-DUSE_OPENMP=ON" \
+            --no-build-isolation \
+            -ve . --user
\ No newline at end of file
diff --git a/cmake/Modules/SetFortranFlags.cmake b/cmake/Modules/SetSwiftestFlags.cmake
similarity index 82%
rename from cmake/Modules/SetFortranFlags.cmake
rename to cmake/Modules/SetSwiftestFlags.cmake
index c5514e749..e6166d787 100644
--- a/cmake/Modules/SetFortranFlags.cmake
+++ b/cmake/Modules/SetSwiftestFlags.cmake
@@ -46,14 +46,13 @@ ELSE()
     MESSAGE(FATAL_ERROR "CMAKE_BUILD_TYPE not valid! ${BUILD_TYPE_MSG}")
 ENDIF(BT STREQUAL "RELEASE")
 
-
 #########################################################
 # If the compiler flags have already been set, return now
 #########################################################
 
 IF(CMAKE_Fortran_FLAGS_RELEASE AND CMAKE_Fortran_FLAGS_TESTING AND CMAKE_Fortran_FLAGS_DEBUG AND CMAKE_Fortran_FLAGS_PROFILE )
     RETURN ()
-ENDIF(CMAKE_Fortran_FLAGS_RELEASE AND CMAKE_Fortran_FLAGS_TESTING AND CMAKE_Fortran_FLAGS_DEBUG AND CMAKE_Fortran_FLAGS_PROFILE)
+ENDIF()
 
 ########################################################################
 # Determine the appropriate flags for this compiler for each build type.
@@ -72,13 +71,11 @@ ENDIF ()
 ### GENERAL FLAGS ###
 #####################
 
-
 # Free form
 IF (COMPILER_OPTIONS STREQUAL "GNU")
     SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
         Fortran "-ffree-form" # GNU
         ) 
-
     # Don't add underscores in symbols for C-compatability
     SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
         Fortran "-fno-underscoring" # GNU
@@ -88,12 +85,10 @@ IF (COMPILER_OPTIONS STREQUAL "GNU")
     SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
         Fortran "-fsignaling-nans " # GNU
         ) 
-    
     # Allows for lines longer than 80 characters without truncation
     SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
         Fortran "-ffree-line-length-512" # GNU (gfortran)
         )
-
     # Sets the dialect standard
     SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
         Fortran "-std=f2018" 
@@ -131,7 +126,6 @@ IF (NOT BUILD_SHARED_LIBS AND NOT WINOPT)
     SET_COMPILE_FLAG(CMAKE_FORTRAN_FLAGS "${CMAKE_FORTRAN_FLAGS}"
         Fortran "-fPIC"
         )
-
     IF (COMPILER_OPTIONS STREQUAL "Intel")
         # Use static Intel libraries
         SET_COMPILE_FLAG(CMAKE_Fortran_LINK_FLAGS "${CMAKE_Fortran_LINK_FLAGS}"
@@ -141,27 +135,27 @@ IF (NOT BUILD_SHARED_LIBS AND NOT WINOPT)
         SET_COMPILE_FLAG(CMAKE_Fortran_LINK_FLAGS "${CMAKE_Fortran_LINK_FLAGS}"
             Fortran "-static_mpi"  # Intel
         )
-
         IF (USE_OPENMP)
             SET_COMPILE_FLAG(CMAKE_Fortran_LINK_FLAGS "${CMAKE_Fortran_LINK_FLAGS}"
                 Fortran "-qopenmp-link=static"  # Intel
             )
         ENDIF (USE_OPENMP)
-
     ELSEIF (COMPILER_OPTIONS STREQUAL "GNU") 
-        # # Set GNU static libraries
-        # SET_COMPILE_FLAG(CMAKE_Fortran_LINK_FLAGS "${CMAKE_Fortran_LINK_FLAGS}"
-        #         Fortran  "-static-libgfortran" 
-        # )
-        # SET_COMPILE_FLAG(CMAKE_Fortran_LINK_FLAGS "${CMAKE_Fortran_LINK_FLAGS}"
-        #         Fortran  "-static-libgcc" 
-        # )
-        # SET_COMPILE_FLAG(CMAKE_Fortran_LINK_FLAGS "${CMAKE_Fortran_LINK_FLAGS}"
-        #         Fortran  "-static-libstdc++" 
-        # )
-        # SET_COMPILE_FLAG(CMAKE_Fortran_LINK_FLAGS "${CMAKE_Fortran_LINK_FLAGS}"
-        #         Fortran  "-static-libquadmath" 
-        # )
+        IF (NOT BUILD_SHARED_LIBS) 
+            # Set GNU static libraries
+            SET_COMPILE_FLAG(CMAKE_Fortran_LINK_FLAGS "${CMAKE_Fortran_LINK_FLAGS}"
+                Fortran  "-static-libgfortran" 
+            )
+            SET_COMPILE_FLAG(CMAKE_Fortran_LINK_FLAGS "${CMAKE_Fortran_LINK_FLAGS}"
+                Fortran  "-static-libgcc" 
+            )
+            SET_COMPILE_FLAG(CMAKE_Fortran_LINK_FLAGS "${CMAKE_Fortran_LINK_FLAGS}"
+                Fortran  "-static-libstdc++" 
+            )
+            SET_COMPILE_FLAG(CMAKE_Fortran_LINK_FLAGS "${CMAKE_Fortran_LINK_FLAGS}"
+                Fortran  "-static-libquadmath" 
+            )
+        ENDIF ()
         IF (USE_OPENMP)
             SET_COMPILE_FLAG(CMAKE_Fortran_LINK_FLAGS "${CMAKE_Fortran_LINK_FLAGS}"
                 Fortran "-lomp"  
@@ -194,55 +188,52 @@ IF (USE_SIMD)
 
         # Optimize for an old enough processor that it should run on most computers
         IF (WINOPT)
-                SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
+            SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
                 Fortran "/Qx${MACHINE_CODE_VALUE}" # Intel
-                )
-                # Generate an extended set of vector functions
-                SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
+            )
+            # Generate an extended set of vector functions
+            SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
                 Fortran "/Qvecabi:cmdtarget" # Intel Windows
-                )
+            )
         ELSE ()
-                SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
+            SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
                 Fortran "-x${MACHINE_CODE_VALUE}" # Intel
-                )
-                # Generate an extended set of vector functions
-                SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
+            )
+            # Generate an extended set of vector functions
+            SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
                 Fortran "-vecabi=cmdtarget" # Intel
-                )
+            )
         ENDIF ()
 
     ELSEIF (COMPILER_OPTIONS STREQUAL "GNU")
         SET(MACHINE_CODE_VALUE "native" CACHE STRING "Tells the compiler which processor features it may target, including which instruction sets and optimizations it may generate.")
-
         # Enables OpenMP SIMD compilation when OpenMP parallelization is disabled. 
         IF (NOT USE_OPENMP)
-                SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
+            SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
                 Fortran "-fno-openmp -fopenmp-simd" # GNU
-                )     
+            )     
         ENDIF (NOT USE_OPENMP)
 
         IF (MACHINE_CODE_VALUE STREQUAL "Host")
-                SET(MACHINE_CODE_VALUE "native" CACHE STRING "native is the GNU equivalent of Host" FORCE)
+            SET(MACHINE_CODE_VALUE "native" CACHE STRING "native is the GNU equivalent of Host" FORCE)
         ENDIF ()
         
         IF (APPLE)
-                SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
+            SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
                 Fortran "-mtune=${MACHINE_CODE_VALUE}" 
-                )
+            )
         ELSE ()
-                SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
+            SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
                 Fortran "-march=${MACHINE_CODE_VALUE}" 
-                )
-                SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
+            )
+            SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}"
                 Fortran "-mtune=${MACHINE_CODE_VALUE}" 
-                )
+            )
         ENDIF ()
-        
     ENDIF ()
     SET(MACHINE_CODE_VALUE ${MACHINE_CODE_VALUE} CACHE STRING "Tells the compiler which processor features it may target, including which instruction sets and optimizations it may generate.")
 ENDIF (USE_SIMD)    
 
-
 ###################
 ### DEBUG FLAGS ###
 ###################
@@ -253,32 +244,35 @@ IF (CMAKE_BUILD_TYPE STREQUAL "DEBUG" OR CMAKE_BUILD_TYPE STREQUAL "TESTING" )
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran REQUIRED "/Od" # Intel Windows
             )
-
+            SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+                C REQUIRED "/0d"
+            )
             # Turn on all warnings 
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "/warn:all" # Intel Windows
             )
-
+            SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+                C "/warn:all" # Intel Windows
+            )
             # Tells the compiler to issue compile-time messages for nonstandard language elements (Fortran 2018).    
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "/stand:f18"  # Intel Windows
             )  
-
             # Traceback
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "/traceback"   # Intel Windows
             )
-
             # Check everything
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "/check:all"      # Intel Windows
             )
-
+            SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+                C "/check:all"      # Intel Windows
+            )
             # Initializes matrices/arrays with NaN values
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "/Qinit:snan,arrays" # Intel Windows
             )
-
             # Does not generate an interface block for each routine in a source file
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "/nogen-interfaces" # Intel Windows
@@ -288,27 +282,25 @@ IF (CMAKE_BUILD_TYPE STREQUAL "DEBUG" OR CMAKE_BUILD_TYPE STREQUAL "TESTING" )
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "/Qftz-"  # Intel Windows
             )
-
             # Enables floating-point invalid, divide-by-zero, and overflow exceptions
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "/fpe-all:0"         # Intel Windows
             )
-
             # Enables floating-point invalid, divide-by-zero, and overflow exceptions
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran  "/fpe:0" # Intel Windows
             )
-
             # Enables debug info
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "/debug:all" # Intel Windows
             )
-
+            SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+                C "/debug:all" # Intel Windows
+            )
             # Disables additional interprocedural optimizations for a single file compilation
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "/Qip-"  # Intel Windows
             )
-
             # Disables prefetch insertion optimization
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "/Qopt-prefetch-"   # Intel Windows
@@ -317,145 +309,166 @@ IF (CMAKE_BUILD_TYPE STREQUAL "DEBUG" OR CMAKE_BUILD_TYPE STREQUAL "TESTING" )
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran REQUIRED "-O0" # All compilers not on Windows
             )
-
+            SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+                C REQUIRED "-O0" # All compilers not on Windows
+            )
             # Turn on all warnings 
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "-warn all" # Intel
             )
-
+            SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+                C "-Wall" # Intel
+            )
             # Tells the compiler to issue compile-time messages for nonstandard language elements (Fortran 2018).    
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "-stand f18"  # Intel
             )  
-
             # Traceback
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "-traceback"   # Intel Group
             )
-
+            SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+                C "-traceback"   # Intel Group
+            )
             # Check everything
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "-check all"       # Intel
             )
-
+            SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+                C "-check=conversions,stack,uninit"       # Intel
+            )
             # Initializes matrices/arrays with NaN values
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "-init=snan,arrays"  # Intel
             )
-
             # Does not generate an interface block for each routine in a source file
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "-nogen-interfaces" # Intel
             )
-
             # Does not generate aposition independent executable
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "-no-pie" # Intel
             )
-
+            SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+                C "-no-pie" # Intel
+            )
             # Does not set denormal results from floating-point calculations to zero
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "-no-ftz" # Intel
             )
-
+            SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+                C "-no-ftz" # Intel
+            )
             # Enables floating-point invalid, divide-by-zero, and overflow exceptions
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "-fpe-all=0"         # Intel
             )
-
             # Enables floating-point invalid, divide-by-zero, and overflow exceptions
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "-fpe0"  # Intel 
             )
-
             # Enables debug info
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "-debug all" # Intel
             )
-
+            SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+                C "-debug all" # Intel
+            )
             # Disables additional interprocedural optimizations for a single file compilation
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "-no-ip" # Intel
             )
-
             # Disables prefetch insertion optimization
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
                 Fortran "-qno-opt-prefetch" # Intel
             )
-
         ENDIF ()
-                
     ELSEIF (COMPILER_OPTIONS STREQUAL "GNU")
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
             Fortran REQUIRED "-Og" # GNU (gfortran)
         )
-
+        SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+            C REQUIRED "-Og" # GNU (gfortran)
+        )
         # Turn on all warnings 
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
-                Fortran "-Wall"     # GNU
+            Fortran "-Wall"     # GNU
+        )
+        SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+            C "-Wall"     # GNU
         )
         # This enables some extra warning flags that are not enabled by -Wall
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
-                Fortran "-Wextra" # GNU
+            Fortran "-Wextra" # GNU
+        )
+        SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+            C "-Wextra" # GNU
         )
-
         # Disable the warning that arrays may be uninitialized, which comes up due to a known bug in gfortran
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
-                Fortran "-Wno-maybe-uninitialized" # GNU
+            Fortran "-Wno-maybe-uninitialized" # GNU
         )
         # Disable the warning about unused dummy arguments. These primarily occur due to interface rules for type-bound procedures used in extendable types.
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
-                Fortran "-Wno-unused-dummy-argument" # GNU
+            Fortran "-Wno-unused-dummy-argument" # GNU
         )
-
         # Tells the compiler to issue compile-time messages for nonstandard language elements (Fortran 2018).    
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
-                Fortran "-fstd=f2018" # GNU
+            Fortran "-fstd=f2018" # GNU
         )  
-
         # Traceback
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
-                Fortran "-fbacktrace"  # GNU (gfortran)
+            Fortran "-fbacktrace"  # GNU (gfortran)
         )
-
         # Sanitize
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
-                Fortran "-fsanitize=address, undefined"  # Gnu 
+            Fortran "-fsanitize=address, undefined"  # Gnu 
+        )
+        SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+            C "-fsanitize=address, undefined"  # Gnu 
         )
-
         # Check everything
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
-                Fortran "-fcheck=all" # GNU 
+            Fortran "-fcheck=all" # GNU 
+        )
+        SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+            C "-fcheck=all" # GNU 
         )
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
-                Fortran "-fstack-check" # GNU 
+            Fortran "-fstack-check" # GNU 
+        )
+        SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+            C "-fstack-check" # GNU 
         )
-
         # Initializes matrices/arrays with NaN values
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
-                Fortran "-finit-real=snan"   # GNU
+            Fortran "-finit-real=snan"   # GNU
         )
-
         # Generates non position-independent code
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
-                Fortran "-fno-PIE" # GNU
+            Fortran "-fno-PIE" # GNU
+        )
+        SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+            C "-fno-PIE" # GNU
         )
-
         # Enables floating-point invalid, divide-by-zero, and overflow exceptions
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
-        Fortran "-ffpe-trap=zero,overflow,underflow" # GNU
+            Fortran "-ffpe-trap=zero,overflow,underflow" # GNU
+        )
+        SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+            C "-ffpe-trap=zero,overflow,underflow" # GNU
         )
-
         # List of floating-point exceptions, whose flag status is printed to ERROR_UNIT when invoking STOP and ERROR STOP
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
-                Fortran "-ffpe-summary=all" # GNU
+            Fortran "-ffpe-summary=all" # GNU
         )
-
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
-                Fortran "-fstack-check" # GNU 
+            Fortran "-fstack-check" # GNU 
+        )
+        SET_COMPILE_FLAG(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}"
+            C "-fstack-check" # GNU 
         )
     ENDIF ()
-
 ENDIF ()
 
 #####################
@@ -463,15 +476,20 @@ ENDIF ()
 #####################
 
 IF (CMAKE_BUILD_TYPE STREQUAL "TESTING" )
-
     # Optimizations
     IF (WINOPT)
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_TESTING "${CMAKE_Fortran_FLAGS_DEBUG}"
-             REQUIRED "/O3" # Intel Windows
+            Fortran REQUIRED "/O3" # Intel Windows
+        )
+        SET_COMPILE_FLAG(CMAKE_C_FLAGS_TESTING "${CMAKE_C_FLAGS_DEBUG}"
+            C REQUIRED "/O3" # Intel Windows
         )
     ELSE ()
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_TESTING "${CMAKE_Fortran_FLAGS_DEBUG}"
-             REQUIRED "-O3" # All compilers not on Windows
+            Fortran REQUIRED "-O3" # All compilers not on Windows
+        )
+        SET_COMPILE_FLAG(CMAKE_C_FLAGS_TESTING "${CMAKE_C_FLAGS_DEBUG}"
+            C REQUIRED "-O3" # All compilers not on Windows
         )
     ENDIF ()
 ENDIF ()
@@ -481,47 +499,38 @@ ENDIF ()
 #####################
 # NOTE: agressive optimizations (-O3) are already turned on by default
 
-
 IF (CMAKE_BUILD_TYPE STREQUAL "RELEASE" OR CMAKE_BUILD_TYPE STREQUAL "PROFILE")
-
     IF (COMPILER_OPTIONS STREQUAL "Intel")
         IF (WINOPT)
             # Unroll loops
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}"
                 Fortran "/unroll"    # Intel Windows
             )
-
             # Inline functions
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}"
                 Fortran "/Qinline"       # Intel Windows
             )
-
             # Calls the Matrix Multiply library
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}"
                 Fortran "/Qopt-matmul" # Intel Windows
             )
-
             # Aligns a variable to a specified boundary and offset
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}"
                 Fortran "/align:all" # Intel Windows
             )
-
             # No floating-point exceptions
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}"
                 Fortran "/fp:no-except"       # Intel Windows
             )
-
             # Generate fused multiply-add instructions
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}"
                 Fortran "/Qfma" # Intel Windows
             )
-
             # Tells the compiler to link to certain libraries in the Intel oneAPI Math Kernel Library (oneMKL). 
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}"
                 Fortran "/Qmkl:cluster" # Intel Windows
                         "/Qmkl"     # Intel Windows
             ) 
-
             # Enables additional interprocedural optimizations for a single file compilation
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}"
                 Fortran "/Qip" # Intel Windows
@@ -531,7 +540,6 @@ IF (CMAKE_BUILD_TYPE STREQUAL "RELEASE" OR CMAKE_BUILD_TYPE STREQUAL "PROFILE")
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}"
                 Fortran "-unroll"    # Intel
             )
-
             # Inline functions
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}"
                 Fortran "-inline"    # Intel
@@ -541,12 +549,10 @@ IF (CMAKE_BUILD_TYPE STREQUAL "RELEASE" OR CMAKE_BUILD_TYPE STREQUAL "PROFILE")
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}"
                 Fortran "-qopt-matmul" # Intel
             )
-
             # Aligns a variable to a specified boundary and offset
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}"
                 Fortran "-align all" # Intel
             )
-
             # No floating-point exceptions
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}"
                 Fortran "-fp-model no-except" # Intel
@@ -554,15 +560,13 @@ IF (CMAKE_BUILD_TYPE STREQUAL "RELEASE" OR CMAKE_BUILD_TYPE STREQUAL "PROFILE")
 
             # Generate fused multiply-add instructions
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}"
-                    Fortran "-fma"  # Intel
+                Fortran "-fma"  # Intel
             )
-
             # Tells the compiler to link to certain libraries in the Intel oneAPI Math Kernel Library (oneMKL). 
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}"
                 Fortran "-qmkl=cluster" # Intel
                         "-qmkl"     # Intel
             ) 
-
             # Enables additional interprocedural optimizations for a single file compilation
             SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}"
                 Fortran "-ip"  # Intel
@@ -572,45 +576,37 @@ IF (CMAKE_BUILD_TYPE STREQUAL "RELEASE" OR CMAKE_BUILD_TYPE STREQUAL "PROFILE")
     ELSEIF(COMPILER_OPTIONS STREQUAL "GNU")
         # Unroll loops
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}"
-                Fortran "-funroll-loops" # GNU
-                )
-
+            Fortran "-funroll-loops" # GNU
+        )
         # Inline functions
         SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}"
-                Fortran "-finline-functions" # GNU
-                )
+            Fortran "-finline-functions" # GNU
+        )
     ENDIF ()
-
 ENDIF ()
  
 #####################
 ### MATH FLAGS ###
 #####################
 IF (COMPILER_OPTIONS STREQUAL "Intel")
-
     IF (WINOPT)
         # Some subroutines require more strict floating point operation optimizations for repeatability
         SET_COMPILE_FLAG(STRICTMATH_FLAGS "${STRICTMATH_FLAGS}"
             Fortran "/fp:precise" # Intel Windows 
         )
-
         SET_COMPILE_FLAG(STRICTMATH_FLAGS "${STRICTMATH_FLAGS}"
             Fortran "/Qprec-div" # Intel Windows 
         ) 
-
         SET_COMPILE_FLAG(STRICTMATH_FLAGS "${STRICTMATH_FLAGS}"
             Fortran "/Qprec-sqrt" # Intel Windows 
         )
-
         SET_COMPILE_FLAG(STRICTMATH_FLAGS "${STRICTMATH_FLAGS}"
             Fortran "/assume:protect-parens" # Intel Windows 
         ) 
-
         # Improves floating-point precision and consistency
         SET_COMPILE_FLAG(STRICTMATH_FLAGS "${STRICTMATH_FLAGS}"
             Fortran "/Qprec" # Intel Windows
         ) 
-
         # Most subroutines can use aggressive optimization of floating point operations without problems.       
         SET_COMPILE_FLAG(FASTMATH_FLAGS "${FASTMATH_FLAGS}"
             Fortran "/fp:fast"       # Intel Windows
@@ -620,46 +616,37 @@ IF (COMPILER_OPTIONS STREQUAL "Intel")
         SET_COMPILE_FLAG(STRICTMATH_FLAGS "${STRICTMATH_FLAGS}"
             Fortran "-fp-module=precise" # Intel 
         )
-
         SET_COMPILE_FLAG(STRICTMATH_FLAGS "${STRICTMATH_FLAGS}"
             Fortran "-prec-div" # Intel 
         ) 
-
         SET_COMPILE_FLAG(STRICTMATH_FLAGS "${STRICTMATH_FLAGS}"
             Fortran "-prec-sqrt" # Intel 
         )
-
         SET_COMPILE_FLAG(STRICTMATH_FLAGS "${STRICTMATH_FLAGS}"
             Fortran "-assume protect-parens" # Intel
         ) 
-
         # Improves floating-point precision and consistency
         SET_COMPILE_FLAG(STRICTMATH_FLAGS "${STRICTMATH_FLAGS}"
             Fortran "-mp1" # Intel Windows
         ) 
-
         # Most subroutines can use aggressive optimization of floating point operations without problems.       
         SET_COMPILE_FLAG(FASTMATH_FLAGS "${FASTMATH_FLAGS}"
             Fortran "-fp-model=fast"       # Intel Windows
         )
-
     ENDIF ()    
-
 ELSEIF (COMPILER_OPTIONS STREQUAL "GNU")
-
     # Some subroutines require more strict floating point operation optimizations for repeatability
     SET_COMPILE_FLAG(STRICTMATH_FLAGS "${STRICTMATH_FLAGS}"
         Fortran "-fno-unsafe-math-optimizations" # GNU
-        )
+    )
     # Disable transformations and optimizations that assume default floating-point rounding behavior. 
     SET_COMPILE_FLAG(STRICTMATH_FLAGS "${STRICTMATH_FLAGS}"
         Fortran "-frounding-math"
-        )
-
+    )
     # Most subroutines can use aggressive optimization of floating point operations without problems.       
     SET_COMPILE_FLAG(FASTMATH_FLAGS "${FASTMATH_FLAGS}"
         Fortran "-ffast-math"    # GNU
-        )
+    )
 ENDIF ()
 
 # Debug mode always uses strict math
@@ -671,7 +658,6 @@ SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}"
 ### PROFILE FLAGS ###
 #####################
 IF (CMAKE_BUILD_TYPE STREQUAL "PROFILE")
-
     IF (COMPILER_OPTIONS STREQUAL "Intel")
     # Enables the optimization reports to be generated
         IF (WINOPT)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index e6c638d33..88b197744 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -22,10 +22,6 @@ IF (COMPILER_OPTIONS STREQUAL "Intel" AND NOT CMAKE_SYSTEM_NAME STREQUAL "Window
     INCLUDE(SetMKL)
 ENDIF ()
 
-# This INCLUDE statement executes code that sets the compile flags for DEBUG,
-# RELEASE, PROFILING, and TESTING.  
-INCLUDE(SetFortranFlags) 
-
 # Add the source files
 SET(STRICT_MATH_FILES
             ${SRC}/collision/collision_generate.f90
@@ -136,9 +132,6 @@ ENDIF()
 SET(SWIFTEST_DRIVER swiftest_driver)
 ADD_EXECUTABLE(${SWIFTEST_DRIVER} ${DRIVER_src})
 
-# Be sure the executable gets packaged with the wheel
-#SET_PROPERTY(TARGET ${SWIFTEST_DRIVER} PROPERTY RUNTIME_OUTPUT_DIRECTORY ${SKBUILD_SCRIPTS_DIR})
-
 #####################################################
 # Add the needed libraries 
 #####################################################