Add files using upload-large-folder tool

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/ADSP-CXX.cmake

@@ -0,0 +1,18 @@
+include(Compiler/CMakeCommonCompilerMacros)
+include(Compiler/ADSP)
+
+__compiler_adsp(CXX)
+
+set(CMAKE_CXX98_STANDARD_COMPILE_OPTION -c++)
+set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION -g++)
+set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON)
+set(CMAKE_CXX_STANDARD_LATEST 98)
+
+if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8.3.0.0)
+  set(CMAKE_CXX11_STANDARD_COMPILE_OPTION -c++11)
+  set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION -c++11 -g++)
+  set(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT ON)
+  set(CMAKE_CXX_STANDARD_LATEST 11)
+endif()
+
+__compiler_check_default_language_standard(CXX 8.0.0.0 98)

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/ARMCC-CXX.cmake

@@ -0,0 +1,2 @@
+include(Compiler/ARMCC)
+__compiler_armcc(CXX)

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/ARMClang-C-FeatureTests.cmake

@@ -0,0 +1 @@
+include(Compiler/Clang-C-FeatureTests)

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/Absoft-Fortran.cmake

@@ -0,0 +1,13 @@
+string(APPEND CMAKE_Fortran_FLAGS_INIT " ")
+string(APPEND CMAKE_Fortran_FLAGS_DEBUG_INIT " -g")
+string(APPEND CMAKE_Fortran_FLAGS_MINSIZEREL_INIT " ")
+string(APPEND CMAKE_Fortran_FLAGS_RELEASE_INIT " -O3")
+string(APPEND CMAKE_Fortran_FLAGS_RELWITHDEBINFO_INIT " -O2 -g")
+set(CMAKE_Fortran_MODDIR_FLAG "-YMOD_OUT_DIR=")
+set(CMAKE_Fortran_MODPATH_FLAG "-p")
+set(CMAKE_Fortran_VERBOSE_FLAG "-v")
+set(CMAKE_Fortran_FORMAT_FIXED_FLAG "-ffixed")
+set(CMAKE_Fortran_FORMAT_FREE_FLAG "-ffree")
+set(CMAKE_Fortran_LINKER_WRAPPER_FLAG "-X")
+set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_ON "-cpp")
+set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_OFF "-no-cpp")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/AppleClang-C.cmake

@@ -0,0 +1,45 @@
+include(Compiler/Clang)
+__compiler_clang(C)
+
+
+if(NOT "x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC")
+  if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+      AND CMAKE_GENERATOR MATCHES "Makefiles"
+      AND CMAKE_DEPFILE_FLAGS_C)
+    # dependencies are computed by the compiler itself
+    set(CMAKE_C_DEPFILE_FORMAT gcc)
+    set(CMAKE_C_DEPENDS_USE_COMPILER TRUE)
+  endif()
+endif()
+
+set(CMAKE_C_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x c)
+
+if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.0)
+  set(CMAKE_C90_STANDARD_COMPILE_OPTION "-std=c90")
+  set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-std=gnu90")
+  set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_C99_STANDARD_COMPILE_OPTION "-std=c99")
+  set(CMAKE_C99_EXTENSION_COMPILE_OPTION "-std=gnu99")
+  set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c11")
+  set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu11")
+  set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_C_STANDARD_LATEST 11)
+endif()
+
+if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 11.0)
+  set(CMAKE_C17_STANDARD_COMPILE_OPTION "-std=c17")
+  set(CMAKE_C17_EXTENSION_COMPILE_OPTION "-std=gnu17")
+  set(CMAKE_C_STANDARD_LATEST 17)
+endif()
+
+if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 11.0.3)
+  set(CMAKE_C23_STANDARD_COMPILE_OPTION "-std=c2x")
+  set(CMAKE_C23_EXTENSION_COMPILE_OPTION "-std=gnu2x")
+  set(CMAKE_C_STANDARD_LATEST 23)
+endif()
+
+__compiler_check_default_language_standard(C 4.0 99 9.1 11 12.0.5 17)

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/AppleClang-CXX.cmake

@@ -0,0 +1,72 @@
+include(Compiler/Clang)
+__compiler_clang(CXX)
+
+set(CMAKE_CXX_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x c++)
+
+if(NOT "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")
+  if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+      AND CMAKE_GENERATOR MATCHES "Makefiles"
+      AND CMAKE_DEPFILE_FLAGS_CXX)
+    # dependencies are computed by the compiler itself
+    set(CMAKE_CXX_DEPFILE_FORMAT gcc)
+    set(CMAKE_CXX_DEPENDS_USE_COMPILER TRUE)
+  endif()
+
+  set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden")
+endif()
+
+if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.0)
+  set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "-std=c++98")
+  set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "-std=gnu++98")
+  set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-std=c++11")
+  set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=gnu++11")
+
+  set(CMAKE_CXX_STANDARD_LATEST 11)
+endif()
+
+if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.1)
+  set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std=c++14")
+  set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++14")
+  set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON)
+  set(CMAKE_CXX_STANDARD_LATEST 14)
+elseif(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.1)
+  # AppleClang 5.0 knows this flag, but does not set a __cplusplus macro greater than 201103L
+  set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std=c++1y")
+  set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++1y")
+  set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON)
+  set(CMAKE_CXX_STANDARD_LATEST 14)
+endif()
+
+if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 10.0)
+  set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std=c++17")
+  set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++17")
+  set(CMAKE_CXX_STANDARD_LATEST 17)
+elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.1)
+  set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std=c++1z")
+  set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++1z")
+  set(CMAKE_CXX_STANDARD_LATEST 17)
+endif()
+
+if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.0)
+    set(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13.0)
+  set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++20")
+  set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++20")
+  set(CMAKE_CXX_STANDARD_LATEST 20)
+elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 10.0)
+  set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++2a")
+  set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++2a")
+  set(CMAKE_CXX_STANDARD_LATEST 20)
+endif()
+
+if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13.0)
+  set(CMAKE_CXX23_STANDARD_COMPILE_OPTION "-std=c++2b")
+  set(CMAKE_CXX23_EXTENSION_COMPILE_OPTION "-std=gnu++2b")
+  set(CMAKE_CXX_STANDARD_LATEST 23)
+endif()
+
+__compiler_check_default_language_standard(CXX 4.0 98)

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/AppleClang-OBJCXX.cmake

@@ -0,0 +1,59 @@
+include(Compiler/Clang-OBJCXX)
+
+
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles"
+    AND CMAKE_DEPFILE_FLAGS_OBJCXX)
+  # dependencies are computed by the compiler itself
+  set(CMAKE_OBJCXX_DEPFILE_FORMAT gcc)
+  set(CMAKE_OBJCXX_DEPENDS_USE_COMPILER TRUE)
+endif()
+
+
+set(CMAKE_OBJCXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden")
+
+if(NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 4.0)
+  set(CMAKE_OBJCXX98_STANDARD_COMPILE_OPTION "-std=c++98")
+  set(CMAKE_OBJCXX98_EXTENSION_COMPILE_OPTION "-std=gnu++98")
+  set(CMAKE_OBJCXX98_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_OBJCXX11_STANDARD_COMPILE_OPTION "-std=c++11")
+  set(CMAKE_OBJCXX11_EXTENSION_COMPILE_OPTION "-std=gnu++11")
+
+  set(CMAKE_OBJCXX_STANDARD_LATEST 11)
+endif()
+
+if(NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 6.1)
+  set(CMAKE_OBJCXX14_STANDARD_COMPILE_OPTION "-std=c++14")
+  set(CMAKE_OBJCXX14_EXTENSION_COMPILE_OPTION "-std=gnu++14")
+  set(CMAKE_OBJCXX14_STANDARD__HAS_FULL_SUPPORT ON)
+  set(CMAKE_OBJCXX_STANDARD_LATEST 14)
+elseif(NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 5.1)
+  # AppleClang 5.0 knows this flag, but does not set a __cplusplus macro greater than 201103L
+  set(CMAKE_OBJCXX14_STANDARD_COMPILE_OPTION "-std=c++1y")
+  set(CMAKE_OBJCXX14_EXTENSION_COMPILE_OPTION "-std=gnu++1y")
+  set(CMAKE_OBJCXX14_STANDARD__HAS_FULL_SUPPORT ON)
+  set(CMAKE_OBJCXX_STANDARD_LATEST 14)
+endif()
+
+if (NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 10.0)
+  set(CMAKE_OBJCXX17_STANDARD_COMPILE_OPTION "-std=c++17")
+  set(CMAKE_OBJCXX17_EXTENSION_COMPILE_OPTION "-std=gnu++17")
+  set(CMAKE_OBJCXX_STANDARD_LATEST 17)
+elseif (NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 6.1)
+  set(CMAKE_OBJCXX17_STANDARD_COMPILE_OPTION "-std=c++1z")
+  set(CMAKE_OBJCXX17_EXTENSION_COMPILE_OPTION "-std=gnu++1z")
+  set(CMAKE_OBJCXX_STANDARD_LATEST 17)
+endif()
+
+if (NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 8.0)
+    set(CMAKE_OBJCXX11_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+if (NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 10.0)
+  set(CMAKE_OBJCXX20_STANDARD_COMPILE_OPTION "-std=c++2a")
+  set(CMAKE_OBJCXX20_EXTENSION_COMPILE_OPTION "-std=gnu++2a")
+  set(CMAKE_OBJCXX_STANDARD_LATEST 20)
+endif()
+
+__compiler_check_default_language_standard(OBJCXX 4.0 98)

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/Clang-DetermineCompiler.cmake

@@ -0,0 +1,4 @@
+
+set(_compiler_id_pp_test "defined(__clang__)")
+
+include("${CMAKE_CURRENT_LIST_DIR}/Clang-DetermineCompilerInternal.cmake")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/Clang-DetermineCompilerInternal.cmake

@@ -0,0 +1,15 @@
+
+set(_compiler_id_version_compute "
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__clang_major__)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__clang_minor__)
+# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__clang_patchlevel__)
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define @PREFIX@SIMULATE_VERSION_MAJOR @MACRO_DEC@(_MSC_VER / 100)
+#  define @PREFIX@SIMULATE_VERSION_MINOR @MACRO_DEC@(_MSC_VER % 100)
+# endif")
+
+set(_compiler_id_simulate "
+# if defined(_MSC_VER)
+#  define @PREFIX@SIMULATE_ID \"MSVC\"
+# endif")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/Clang-OBJCXX.cmake

@@ -0,0 +1,11 @@
+include(Compiler/Clang)
+__compiler_clang(OBJCXX)
+__compiler_clang_cxx_standards(OBJCXX)
+
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
+    AND CMAKE_DEPFILE_FLAGS_OBJCXX)
+  # dependencies are computed by the compiler itself
+  set(CMAKE_OBJCXX_DEPFILE_FORMAT gcc)
+  set(CMAKE_OBJCXX_DEPENDS_USE_COMPILER TRUE)
+endif()

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/Compaq-C-DetermineCompiler.cmake

@@ -0,0 +1,8 @@
+
+set(_compiler_id_pp_test "defined(__DECC)")
+
+set(_compiler_id_version_compute "
+  /* __DECC_VER = VVRRTPPPP */
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__DECC_VER/10000000)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__DECC_VER/100000  % 100)
+# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__DECC_VER         % 10000)")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/Cray-C.cmake

@@ -0,0 +1,26 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Compiler/Cray)
+__compiler_cray(C)
+
+string(APPEND CMAKE_C_FLAGS_MINSIZEREL_INIT " -DNDEBUG")
+string(APPEND CMAKE_C_FLAGS_RELEASE_INIT " -DNDEBUG")
+
+if (CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 8.1)
+  set(CMAKE_C90_STANDARD_COMPILE_OPTION  -h noc99,conform)
+  set(CMAKE_C90_EXTENSION_COMPILE_OPTION -h noc99,gnu)
+  set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON)
+  set(CMAKE_C99_STANDARD_COMPILE_OPTION  -h c99,conform)
+  set(CMAKE_C99_EXTENSION_COMPILE_OPTION -h c99,gnu)
+  set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON)
+  set(CMAKE_C_STANDARD_LATEST 99)
+  if (CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 8.5)
+    set(CMAKE_C11_STANDARD_COMPILE_OPTION  -h std=c11,conform)
+    set(CMAKE_C11_EXTENSION_COMPILE_OPTION -h std=c11,gnu)
+    set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON)
+    set(CMAKE_C_STANDARD_LATEST 11)
+  endif ()
+endif ()
+
+__compiler_check_default_language_standard(C 8.1 99)

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/Cray-CXX.cmake

@@ -0,0 +1,29 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Compiler/Cray)
+__compiler_cray(CXX)
+
+string(APPEND CMAKE_CXX_FLAGS_MINSIZEREL_INIT " -DNDEBUG")
+string(APPEND CMAKE_CXX_FLAGS_RELEASE_INIT " -DNDEBUG")
+
+if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8.1)
+  set(CMAKE_CXX98_STANDARD_COMPILE_OPTION  -h conform)
+  set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION -h gnu)
+  set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON)
+  set(CMAKE_CXX_STANDARD_LATEST 98)
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.4)
+    set(CMAKE_CXX11_STANDARD_COMPILE_OPTION  -h std=c++11)
+    set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION -h std=c++11,gnu)
+    set(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT ON)
+    set(CMAKE_CXX_STANDARD_LATEST 11)
+  endif()
+  if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.6)
+    set(CMAKE_CXX14_STANDARD_COMPILE_OPTION  -h std=c++14)
+    set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION -h std=c++14,gnu)
+    set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON)
+    set(CMAKE_CXX_STANDARD_LATEST 14)
+  endif ()
+endif ()
+
+__compiler_check_default_language_standard(CXX 8.1 98)

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/Cray-DetermineCompiler.cmake

@@ -0,0 +1,6 @@
+
+set(_compiler_id_pp_test "defined(_CRAYC)")
+
+set(_compiler_id_version_compute "
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(_RELEASE_MAJOR)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(_RELEASE_MINOR)")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/Cray-Fortran.cmake

@@ -0,0 +1,25 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Compiler/Cray)
+__compiler_cray(Fortran)
+
+set(CMAKE_Fortran_SUBMODULE_SEP "")
+set(CMAKE_Fortran_SUBMODULE_EXT ".mod")
+set(CMAKE_Fortran_MODOUT_FLAG -em)
+set(CMAKE_Fortran_MODDIR_FLAG -J)
+set(CMAKE_Fortran_MODDIR_DEFAULT .)
+set(CMAKE_Fortran_FORMAT_FIXED_FLAG "-f fixed")
+set(CMAKE_Fortran_FORMAT_FREE_FLAG "-f free")
+
+if (NOT CMAKE_Fortran_COMPILER_VERSION VERSION_LESS 8.5)
+  set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_ON "-eT")
+  set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_OFF "-dT")
+else()
+  set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_ON "-eZ")
+  set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_OFF "-dZ")
+endif()
+
+if (NOT CMAKE_Fortran_COMPILER_VERSION VERSION_LESS 11.0)
+  set(CMAKE_Fortran_PREPROCESS_SOURCE "<CMAKE_Fortran_COMPILER> -o <PREPROCESSED_SOURCE> <DEFINES> <INCLUDES> <FLAGS> -eP <SOURCE>")
+endif()

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/CrayClang-CXX.cmake

@@ -0,0 +1,37 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Compiler/CrayClang)
+__compiler_cray_clang(CXX)
+
+
+set(CMAKE_CXX_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x c++)
+set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden")
+
+string(APPEND CMAKE_CXX_FLAGS_MINSIZEREL_INIT " -DNDEBUG")
+string(APPEND CMAKE_CXX_FLAGS_RELEASE_INIT " -DNDEBUG")
+
+set(CMAKE_CXX98_STANDARD_COMPILE_OPTION  -std=c++98)
+set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION -std=gnu++98)
+set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON)
+
+set(CMAKE_CXX11_STANDARD_COMPILE_OPTION  -std=c++11)
+set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION -std=gnu++11)
+set(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT ON)
+
+set(CMAKE_CXX14_STANDARD_COMPILE_OPTION  -std=c++14)
+set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION -std=gnu++14)
+set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON)
+
+set(CMAKE_CXX17_STANDARD_COMPILE_OPTION  -std=c++17)
+set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION -std=gnu++17)
+
+set(CMAKE_CXX20_STANDARD_COMPILE_OPTION  -std=c++20)
+set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION -std=gnu++20)
+
+set(CMAKE_CXX23_STANDARD_COMPILE_OPTION  -std=c++2b)
+set(CMAKE_CXX23_EXTENSION_COMPILE_OPTION -std=gnu++2b)
+
+set(CMAKE_CXX_STANDARD_LATEST 23)
+
+__compiler_check_default_language_standard(CXX 15.0.0 14)

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/CrayClang-DetermineCompiler.cmake

@@ -0,0 +1,8 @@
+set(_compiler_id_pp_test "defined(__clang__) && defined(__cray__)")
+
+set(_compiler_id_version_compute "
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__cray_major__)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__cray_minor__)
+# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__cray_patchlevel__)
+# define @PREFIX@COMPILER_VERSION_INTERNAL_STR __clang_version__
+")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/CrayPrgEnv-CXX.cmake

@@ -0,0 +1,7 @@
+if(__craylinux_crayprgenv_cxx)
+  return()
+endif()
+set(__craylinux_crayprgenv_cxx 1)
+
+include(Compiler/CrayPrgEnv)
+__CrayPrgEnv_setup(CXX)

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/Fujitsu-DetermineCompiler.cmake

@@ -0,0 +1,17 @@
+
+set(_compiler_id_pp_test "defined(__FUJITSU)")
+
+set(_compiler_id_version_compute "
+# if defined(__FCC_version__)
+#   define @PREFIX@COMPILER_VERSION __FCC_version__
+# elif defined(__FCC_major__)
+#   define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__FCC_major__)
+#   define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__FCC_minor__)
+#   define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__FCC_patchlevel__)
+# endif
+# if defined(__fcc_version)
+#   define @PREFIX@COMPILER_VERSION_INTERNAL @MACRO_DEC@(__fcc_version)
+# elif defined(__FCC_VERSION)
+#   define @PREFIX@COMPILER_VERSION_INTERNAL @MACRO_DEC@(__FCC_VERSION)
+# endif
+")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/FujitsuClang.cmake

@@ -0,0 +1,11 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+# This module is shared by multiple languages; use include blocker.
+if(__COMPILER_FUJITSUCLANG)
+  return()
+endif()
+set(__COMPILER_FUJITSUCLANG 1)
+
+include(Compiler/Clang)

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/G95-Fortran.cmake

@@ -0,0 +1,13 @@
+string(APPEND CMAKE_Fortran_FLAGS_INIT " ")
+string(APPEND CMAKE_Fortran_FLAGS_DEBUG_INIT " -g")
+string(APPEND CMAKE_Fortran_FLAGS_MINSIZEREL_INIT " -Os")
+string(APPEND CMAKE_Fortran_FLAGS_RELEASE_INIT " -O3")
+string(APPEND CMAKE_Fortran_FLAGS_RELWITHDEBINFO_INIT " -O2 -g")
+set(CMAKE_Fortran_MODDIR_FLAG "-fmod=")
+set(CMAKE_Fortran_VERBOSE_FLAG "-v")
+set(CMAKE_Fortran_FORMAT_FIXED_FLAG "-ffixed-form")
+set(CMAKE_Fortran_FORMAT_FREE_FLAG "-ffree-form")
+set(CMAKE_Fortran_LINKER_WRAPPER_FLAG "-Wl,")
+set(CMAKE_Fortran_LINKER_WRAPPER_FLAG_SEP ",")
+set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_ON "-cpp")
+set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_OFF "-no-cpp")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/GHS-C.cmake

@@ -0,0 +1,10 @@
+include(Compiler/GHS)
+
+set(CMAKE_C_VERBOSE_FLAG "-v")
+set(CMAKE_C_OUTPUT_EXTENSION ".o")
+
+string(APPEND CMAKE_C_FLAGS_INIT " ")
+string(APPEND CMAKE_C_FLAGS_DEBUG_INIT " -Odebug -g")
+string(APPEND CMAKE_C_FLAGS_MINSIZEREL_INIT " -Ospace")
+string(APPEND CMAKE_C_FLAGS_RELEASE_INIT " -O")
+string(APPEND CMAKE_C_FLAGS_RELWITHDEBINFO_INIT " -O -g")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/GHS-DetermineCompiler.cmake

@@ -0,0 +1,9 @@
+set(_compiler_id_pp_test "defined(__ghs__)")
+
+set(_compiler_id_version_compute "
+/* __GHS_VERSION_NUMBER = VVVVRP */
+# ifdef __GHS_VERSION_NUMBER
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__GHS_VERSION_NUMBER / 100)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__GHS_VERSION_NUMBER / 10 % 10)
+# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__GHS_VERSION_NUMBER      % 10)
+# endif")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/GNU-ASM.cmake

@@ -0,0 +1,13 @@
+# This file is loaded when gcc/g++ is used for assembler files (the "ASM" cmake language)
+include(Compiler/GNU)
+
+set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s;S;asm)
+
+__compiler_gnu(ASM)
+
+if(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_MATCH STREQUAL "GNU assembler")
+  set(CMAKE_DEPFILE_FLAGS_ASM${ASM_DIALECT} "--MD <DEP_FILE>")
+  set(CMAKE_ASM${ASM_DIALECT}_LINK_EXECUTABLE
+    "<CMAKE_LINKER> <FLAGS> <CMAKE_ASM${ASM_DIALECT}_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>")
+  set(CMAKE_ASM_DEFINE_FLAG "--defsym ")
+endif()

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/GNU-C.cmake

@@ -0,0 +1,16 @@
+include(Compiler/GNU)
+__compiler_gnu(C)
+__compiler_gnu_c_standards(C)
+
+
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
+    AND CMAKE_DEPFILE_FLAGS_C)
+  # dependencies are computed by the compiler itself
+  set(CMAKE_C_DEPFILE_FORMAT gcc)
+  set(CMAKE_C_DEPENDS_USE_COMPILER TRUE)
+endif()
+
+set(CMAKE_C_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x c)
+
+__compiler_check_default_language_standard(C 3.4 90 5.0 11 8.1 17)

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake

@@ -0,0 +1,15 @@
+
+set(_compiler_id_pp_test "defined(__GNUC__) || defined(__GNUG__)")
+
+set(_compiler_id_version_compute "
+# if defined(__GNUC__)
+#  define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__GNUC__)
+# else
+#  define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__GNUG__)
+# endif
+# if defined(__GNUC_MINOR__)
+#  define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__GNUC_PATCHLEVEL__)
+# endif")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake

@@ -0,0 +1,47 @@
+include(Compiler/GNU)
+__compiler_gnu(CXX)
+__compiler_gnu_cxx_standards(CXX)
+
+
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
+    AND CMAKE_DEPFILE_FLAGS_CXX)
+  # dependencies are computed by the compiler itself
+  set(CMAKE_CXX_DEPFILE_FORMAT gcc)
+  set(CMAKE_CXX_DEPENDS_USE_COMPILER TRUE)
+endif()
+
+set(CMAKE_CXX_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x c++)
+
+if (WIN32)
+  if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.6)
+    set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fno-keep-inline-dllexport")
+  endif()
+else()
+  if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.0)
+    set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden")
+  endif()
+endif()
+
+__compiler_check_default_language_standard(CXX 3.4 98 6.0 14 11.1 17)
+
+if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 14.0)
+  string(CONCAT CMAKE_CXX_SCANDEP_SOURCE
+    "<CMAKE_CXX_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -E -x c++ <SOURCE>"
+    " -MT <DYNDEP_FILE> -MD -MF <DEP_FILE>"
+    " -fmodules-ts -fdeps-file=<DYNDEP_FILE> -fdeps-target=<OBJECT> -fdeps-format=p1689r5"
+    " -o <PREPROCESSED_SOURCE>")
+  set(CMAKE_CXX_MODULE_MAP_FORMAT "gcc")
+  string(CONCAT CMAKE_CXX_MODULE_MAP_FLAG
+    # Turn on modules.
+    "-fmodules-ts"
+    # Read the module mapper file.
+    " -fmodule-mapper=<MODULE_MAP_FILE>"
+    # Make sure dependency tracking is enabled (missing from `try_*`).
+    " -MD"
+    # Suppress `CXX_MODULES +=` from generated depfile snippets.
+    " -fdeps-format=p1689r5"
+    # Force C++ as a language.
+    " -x c++")
+  set(CMAKE_CXX_MODULE_BMI_ONLY_FLAG "-fmodule-only")
+endif()

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/HP-ASM.cmake

@@ -0,0 +1,3 @@
+set(CMAKE_ASM_VERBOSE_FLAG "-v")
+
+set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s )

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/HP-C-DetermineCompiler.cmake

@@ -0,0 +1,8 @@
+
+set(_compiler_id_pp_test "defined(__HP_cc)")
+
+set(_compiler_id_version_compute "
+  /* __HP_cc = VVRRPP */
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__HP_cc/10000)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__HP_cc/100 % 100)
+# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__HP_cc     % 100)")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/IAR-C.cmake

@@ -0,0 +1,86 @@
+# This file is processed when the IAR C Compiler is used
+#
+# C Language Specification support
+#  - Newer versions of the IAR C Compiler require the --c89 flag to build a file under the C90 standard.
+#  - Earlier versions of the compiler had C90 by default, not requiring the backward-compatibility flag.
+#
+# The IAR Language Extensions
+#  - The IAR Language Extensions can be enabled by -e flag
+#
+include(Compiler/IAR)
+include(Compiler/CMakeCommonCompilerMacros)
+
+if(NOT CMAKE_C_COMPILER_VERSION)
+  message(FATAL_ERROR "Could not detect CMAKE_C_COMPILER_VERSION. This should be automatic. Check your product license.\n")
+endif()
+
+# Unused after CMP0128
+set(CMAKE_C_EXTENSION_COMPILE_OPTION -e)
+
+if(CMAKE_C_COMPILER_VERSION_INTERNAL VERSION_GREATER 7)
+  set(CMAKE_C90_STANDARD_COMPILE_OPTION --c89)
+  set(CMAKE_C90_EXTENSION_COMPILE_OPTION --c89 -e)
+else()
+  set(CMAKE_C90_STANDARD_COMPILE_OPTION "")
+  set(CMAKE_C90_EXTENSION_COMPILE_OPTION -e)
+endif()
+
+set(CMAKE_C${CMAKE_C_STANDARD_COMPUTED_DEFAULT}_STANDARD_COMPILE_OPTION "")
+set(CMAKE_C${CMAKE_C_STANDARD_COMPUTED_DEFAULT}_EXTENSION_COMPILE_OPTION -e)
+
+# Architecture specific
+if("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "ARM")
+  if (CMAKE_C_COMPILER_VERSION VERSION_LESS 5)
+    # IAR C Compiler for Arm prior version 5.xx uses XLINK. Support in CMake is not implemented.
+    message(FATAL_ERROR "IAR C Compiler for Arm version ${CMAKE_C_COMPILER_VERSION} not supported by CMake.")
+  endif()
+  __compiler_iar_ilink(C)
+  __compiler_check_default_language_standard(C 5.10 90 6.10 99 8.10 11 8.40 17)
+
+elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "RX")
+  __compiler_iar_ilink(C)
+  __compiler_check_default_language_standard(C 1.10 90 2.10 99 4.10 11 4.20 17)
+
+elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "RH850")
+  __compiler_iar_ilink(C)
+  __compiler_check_default_language_standard(C 1.10 90 1.10 99 2.10 11 2.21 17)
+
+elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "RL78")
+  if(CMAKE_C_COMPILER_VERSION VERSION_LESS 2)
+    # IAR C Compiler for RL78 prior version 2.xx uses XLINK. Support in CMake is not implemented.
+    message(FATAL_ERROR "IAR C Compiler for RL78 version ${CMAKE_C_COMPILER_VERSION} not supported by CMake.")
+  endif()
+  __compiler_iar_ilink(C)
+  __compiler_check_default_language_standard(C 2.10 90 2.10 99 4.10 11 4.20 17)
+
+elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "RISCV")
+  __compiler_iar_ilink(C)
+  __compiler_check_default_language_standard(C 1.10 90 1.10 99 1.10 11 1.21 17)
+
+elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "AVR")
+  __compiler_iar_xlink(C)
+  __compiler_check_default_language_standard(C 7.10 99 8.10 17)
+  set(CMAKE_C_OUTPUT_EXTENSION ".r90")
+
+elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "MSP430")
+  __compiler_iar_xlink(C)
+  __compiler_check_default_language_standard(C 1.10 90 5.10 99)
+  set(CMAKE_C_OUTPUT_EXTENSION ".r43")
+
+elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "V850")
+  __compiler_iar_xlink(C)
+  __compiler_check_default_language_standard(C 1.10 90 4.10 99)
+  set(CMAKE_C_OUTPUT_EXTENSION ".r85")
+
+elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "8051")
+  __compiler_iar_xlink(C)
+  __compiler_check_default_language_standard(C 6.10 90 8.10 99)
+  set(CMAKE_C_OUTPUT_EXTENSION ".r51")
+
+elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "STM8")
+  __compiler_iar_ilink(C)
+  __compiler_check_default_language_standard(C 3.11 90 3.11 99)
+
+else()
+  message(FATAL_ERROR "CMAKE_C_COMPILER_ARCHITECTURE_ID not detected. This should be automatic.")
+endif()

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/IAR.cmake

@@ -0,0 +1,66 @@
+# This file is processed when the IAR C/C++ Compiler is used
+#
+# CPU <arch> supported in CMake: 8051, Arm, AVR, MSP430, RH850, RISC-V, RL78, RX, STM8 and V850
+#
+# The compiler user documentation is architecture-dependent
+# and it can found with the product installation under <arch>/doc/{EW,BX}<arch>_DevelopmentGuide.ENU.pdf
+#
+#
+include_guard()
+
+macro(__compiler_iar_common lang)
+  if ("x${lang}" MATCHES "^x(C|CXX)$")
+    set(CMAKE_${lang}_COMPILE_OBJECT             "<CMAKE_${lang}_COMPILER> ${CMAKE_IAR_${lang}_FLAG} --silent <SOURCE> <DEFINES> <INCLUDES> <FLAGS> -o <OBJECT>")
+    set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE "<CMAKE_${lang}_COMPILER> ${CMAKE_IAR_${lang}_FLAG} --silent <SOURCE> <DEFINES> <INCLUDES> <FLAGS> --preprocess=cnl <PREPROCESSED_SOURCE>")
+    set(CMAKE_${lang}_CREATE_ASSEMBLY_SOURCE     "<CMAKE_${lang}_COMPILER> ${CMAKE_IAR_${lang}_FLAG} --silent <SOURCE> <DEFINES> <INCLUDES> <FLAGS> -lAH <ASSEMBLY_SOURCE> -o <OBJECT>.dummy")
+
+    set(CMAKE_DEPFILE_FLAGS_${lang} "--dependencies=ns <DEP_FILE>")
+
+    string(APPEND CMAKE_${lang}_FLAGS_INIT " ")
+    string(APPEND CMAKE_${lang}_FLAGS_DEBUG_INIT " -r")
+    string(APPEND CMAKE_${lang}_FLAGS_RELEASE_INIT " -Oh -DNDEBUG")
+    string(APPEND CMAKE_${lang}_FLAGS_MINSIZEREL_INIT " -Ohz -DNDEBUG")
+    string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " -Oh -r -DNDEBUG")
+  endif()
+
+  set(CMAKE_${lang}_OUTPUT_EXTENSION_REPLACE 1)
+  set(CMAKE_${lang}_RESPONSE_FILE_FLAG "-f ")
+  set(CMAKE_${lang}_RESPONSE_FILE_LINK_FLAG "-f ")
+
+  set(CMAKE_${lang}_ARCHIVE_FINISH "")
+endmacro()
+
+macro(__compiler_iar_ilink lang)
+  set(CMAKE_EXECUTABLE_SUFFIX ".elf")
+  set(CMAKE_${lang}_OUTPUT_EXTENSION ".o")
+
+  __compiler_iar_common(${lang})
+
+  string(APPEND CMAKE_EXE_LINKER_FLAGS_INIT " --silent")
+  set(CMAKE_${lang}_LINK_EXECUTABLE "<CMAKE_LINKER> <OBJECTS> <CMAKE_${lang}_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES> -o <TARGET>")
+
+  set(CMAKE_${lang}_CREATE_STATIC_LIBRARY "<CMAKE_AR> <TARGET> --create <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_${lang}_ARCHIVE_CREATE "<CMAKE_AR> <TARGET> --create <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_${lang}_ARCHIVE_APPEND "<CMAKE_AR> <TARGET> --replace <LINK_FLAGS> <OBJECTS>")
+endmacro()
+
+macro(__compiler_iar_xlink lang)
+  set(CMAKE_EXECUTABLE_SUFFIX ".bin")
+
+  __compiler_iar_common(${lang})
+
+  string(APPEND CMAKE_EXE_LINKER_FLAGS_INIT " -S")
+  set(CMAKE_${lang}_LINK_EXECUTABLE "<CMAKE_LINKER> <OBJECTS> <CMAKE_${lang}_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES> -o <TARGET>")
+
+  set(CMAKE_${lang}_CREATE_STATIC_LIBRARY "<CMAKE_AR> <TARGET> <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_${lang}_ARCHIVE_CREATE "<CMAKE_AR> <TARGET> <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_${lang}_ARCHIVE_APPEND "")
+
+  set(CMAKE_LIBRARY_PATH_FLAG "-I")
+endmacro()
+
+macro(__assembler_iar_deps flag min_version)
+  if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL ${min_version})
+    set(CMAKE_DEPFILE_FLAGS_ASM "${flag} <DEP_FILE>")
+  endif()
+endmacro()

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/IBMClang-ASM.cmake

@@ -0,0 +1,5 @@
+include(Compiler/IBMClang)
+
+set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s;S;asm)
+
+__compiler_ibmclang(ASM)

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/IBMClang-CXX-DetermineCompiler.cmake

@@ -0,0 +1,8 @@
+set(_compiler_id_pp_test "defined(__open_xl__) && defined(__clang__)")
+
+set(_compiler_id_version_compute "
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__open_xl_version__)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__open_xl_release__)
+# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__open_xl_modification__)
+# define @PREFIX@COMPILER_VERSION_TWEAK @MACRO_DEC@(__open_xl_ptf_fix_level__)
+")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/Intel-ASM.cmake

@@ -0,0 +1,12 @@
+include(Compiler/Intel)
+__compiler_intel(ASM)
+
+string(APPEND CMAKE_ASM_FLAGS_MINSIZEREL_INIT " -DNDEBUG")
+string(APPEND CMAKE_ASM_FLAGS_RELEASE_INIT " -DNDEBUG")
+string(APPEND CMAKE_ASM_FLAGS_RELWITHDEBINFO_INIT " -DNDEBUG")
+
+if(UNIX)
+  set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s;S)
+else()
+  set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS asm)
+endif()

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/Intel-C.cmake

@@ -0,0 +1,65 @@
+include(Compiler/Intel)
+__compiler_intel(C)
+
+string(APPEND CMAKE_C_FLAGS_MINSIZEREL_INIT " -DNDEBUG")
+string(APPEND CMAKE_C_FLAGS_RELEASE_INIT " -DNDEBUG")
+string(APPEND CMAKE_C_FLAGS_RELWITHDEBINFO_INIT " -DNDEBUG")
+
+set(CMAKE_DEPFILE_FLAGS_C "-MD -MT <DEP_TARGET> -MF <DEP_FILE>")
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles|WMake")
+  # dependencies are computed by the compiler itself
+  set(CMAKE_C_DEPFILE_FORMAT gcc)
+  set(CMAKE_C_DEPENDS_USE_COMPILER TRUE)
+endif()
+
+if("x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC")
+
+  set(CMAKE_C_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -TC)
+  set(CMAKE_C_CLANG_TIDY_DRIVER_MODE "cl")
+  set(CMAKE_C_INCLUDE_WHAT_YOU_USE_DRIVER_MODE "cl")
+
+  if (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 12.0)
+    set(CMAKE_C90_STANDARD_COMPILE_OPTION "-Qstd=c89")
+    set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-Qstd=c89")
+    set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON)
+    set(CMAKE_C99_STANDARD_COMPILE_OPTION "-Qstd=c99")
+    set(CMAKE_C99_EXTENSION_COMPILE_OPTION "-Qstd=c99")
+    set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON)
+    set(CMAKE_C_STANDARD_LATEST 99)
+  endif()
+
+  if (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 16.0.0)
+    set(CMAKE_C11_STANDARD_COMPILE_OPTION "-Qstd=c11")
+    set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-Qstd=c11")
+    set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON)
+    set(CMAKE_C_STANDARD_LATEST 11)
+  endif()
+
+else()
+
+  set(CMAKE_C_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x c)
+
+  if (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 12.0)
+    set(CMAKE_C90_STANDARD_COMPILE_OPTION "-std=c89")
+    set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-std=gnu89")
+    set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON)
+    set(CMAKE_C99_STANDARD_COMPILE_OPTION "-std=c99")
+    set(CMAKE_C99_EXTENSION_COMPILE_OPTION "-std=gnu99")
+    set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON)
+    set(CMAKE_C_STANDARD_LATEST 99)
+  endif()
+
+  if (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 15.0.0)
+    set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c11")
+    set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu11")
+    set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON)
+    set(CMAKE_C_STANDARD_LATEST 11)
+  endif()
+
+endif()
+
+__compiler_check_default_language_standard(C 12.0 90 15.0.0 11)
+
+set(CMAKE_C_CREATE_PREPROCESSED_SOURCE "<CMAKE_C_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
+set(CMAKE_C_CREATE_ASSEMBLY_SOURCE "<CMAKE_C_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -S <SOURCE> -o <ASSEMBLY_SOURCE>")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/Intel-CXX.cmake

@@ -0,0 +1,116 @@
+include(Compiler/Intel)
+__compiler_intel(CXX)
+
+string(APPEND CMAKE_CXX_FLAGS_MINSIZEREL_INIT " -DNDEBUG")
+string(APPEND CMAKE_CXX_FLAGS_RELEASE_INIT " -DNDEBUG")
+string(APPEND CMAKE_CXX_FLAGS_RELWITHDEBINFO_INIT " -DNDEBUG")
+
+set(CMAKE_DEPFILE_FLAGS_CXX "-MD -MT <DEP_TARGET> -MF <DEP_FILE>")
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles|WMake")
+  # dependencies are computed by the compiler itself
+  set(CMAKE_CXX_DEPFILE_FORMAT gcc)
+  set(CMAKE_CXX_DEPENDS_USE_COMPILER TRUE)
+endif()
+
+if("x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")
+
+  set(CMAKE_CXX_CLANG_TIDY_DRIVER_MODE "cl")
+  set(CMAKE_CXX_INCLUDE_WHAT_YOU_USE_DRIVER_MODE "cl")
+
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.1)
+    set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "")
+    set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON)
+
+    if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13.0)
+      set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-Qstd=c++11")
+      set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-Qstd=c++11")
+    else()
+      set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-Qstd=c++0x")
+      set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-Qstd=c++0x")
+    endif()
+
+    set(CMAKE_CXX_STANDARD_LATEST 11)
+  endif()
+
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16.0)
+    set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-Qstd=c++14")
+    set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-Qstd=c++14")
+    set(CMAKE_CXX_STANDARD_LATEST 14)
+  endif()
+
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0.0)
+    set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-Qstd=c++17")
+    set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-Qstd=c++17")
+    set(CMAKE_CXX_STANDARD_LATEST 17)
+  endif()
+
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0.0)
+    set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-Qstd=c++20")
+    set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-Qstd=c++20")
+    set(CMAKE_CXX_STANDARD_LATEST 20)
+  endif()
+
+else()
+
+  set(CMAKE_CXX_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x c++)
+
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.1)
+    set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "-std=c++98")
+    set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "-std=gnu++98")
+    set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON)
+
+    if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13.0)
+      set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-std=c++11")
+      set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=gnu++11")
+    else()
+      set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-std=c++0x")
+      set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=gnu++0x")
+    endif()
+
+    set(CMAKE_CXX_STANDARD_LATEST 11)
+  endif()
+
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 15.0)
+    set(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT ON)
+  endif()
+
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 15.0.2)
+    set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std=c++14")
+    set(CMAKE_CXX_STANDARD_LATEST 14)
+  elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 15.0.0)
+    set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std=c++1y")
+    set(CMAKE_CXX_STANDARD_LATEST 14)
+  endif()
+
+  # Intel 15.0.2 accepts c++14 instead of c++1y, but not gnu++14
+  # instead of gnu++1y.  Intel 17.0.0 accepts gnu++14 too.
+  if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 17.0)
+    set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++14")
+  elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 15.0.0)
+    set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++1y")
+  endif()
+
+  if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 17.0)
+    set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON)
+  endif()
+
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0.0)
+    set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std=c++17")
+    set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++17")
+    set(CMAKE_CXX_STANDARD_LATEST 17)
+  endif()
+
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0.0.20190206)
+    set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++20")
+    set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++20")
+    set(CMAKE_CXX_STANDARD_LATEST 20)
+  endif()
+
+endif()
+
+__compiler_check_default_language_standard(CXX 12.1 98)
+
+set(CMAKE_CXX_CREATE_PREPROCESSED_SOURCE "<CMAKE_CXX_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
+set(CMAKE_CXX_CREATE_ASSEMBLY_SOURCE "<CMAKE_CXX_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -S <SOURCE> -o <ASSEMBLY_SOURCE>")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/Intel-DetermineCompiler.cmake

@@ -0,0 +1,49 @@
+
+set(_compiler_id_pp_test "defined(__INTEL_COMPILER) || defined(__ICC)")
+
+set(_compiler_id_version_compute "
+  /* __INTEL_COMPILER = VRP prior to 2021, and then VVVV for 2021 and later,
+     except that a few beta releases use the old format with V=2021.  */
+# if __INTEL_COMPILER < 2021 || __INTEL_COMPILER == 202110 || __INTEL_COMPILER == 202111
+#  define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__INTEL_COMPILER/100)
+#  define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__INTEL_COMPILER/10 % 10)
+#  if defined(__INTEL_COMPILER_UPDATE)
+#   define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__INTEL_COMPILER_UPDATE)
+#  else
+#   define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__INTEL_COMPILER   % 10)
+#  endif
+# else
+#  define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__INTEL_COMPILER)
+#  define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__INTEL_COMPILER_UPDATE)
+   /* The third version component from --version is an update index,
+      but no macro is provided for it.  */
+#  define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(0)
+# endif
+# if defined(__INTEL_COMPILER_BUILD_DATE)
+   /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */
+#  define @PREFIX@COMPILER_VERSION_TWEAK @MACRO_DEC@(__INTEL_COMPILER_BUILD_DATE)
+# endif
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define @PREFIX@SIMULATE_VERSION_MAJOR @MACRO_DEC@(_MSC_VER / 100)
+#  define @PREFIX@SIMULATE_VERSION_MINOR @MACRO_DEC@(_MSC_VER % 100)
+# endif
+# if defined(__GNUC__)
+#  define @PREFIX@SIMULATE_VERSION_MAJOR @MACRO_DEC@(__GNUC__)
+# elif defined(__GNUG__)
+#  define @PREFIX@SIMULATE_VERSION_MAJOR @MACRO_DEC@(__GNUG__)
+# endif
+# if defined(__GNUC_MINOR__)
+#  define @PREFIX@SIMULATE_VERSION_MINOR @MACRO_DEC@(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define @PREFIX@SIMULATE_VERSION_PATCH @MACRO_DEC@(__GNUC_PATCHLEVEL__)
+# endif")
+
+set(_compiler_id_simulate "
+# if defined(_MSC_VER)
+#  define @PREFIX@SIMULATE_ID \"MSVC\"
+# endif
+# if defined(__GNUC__)
+#  define @PREFIX@SIMULATE_ID \"GNU\"
+# endif")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/Intel.cmake

@@ -0,0 +1,61 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+# This module is shared by multiple languages; use include blocker.
+if(__COMPILER_INTEL)
+  return()
+endif()
+set(__COMPILER_INTEL 1)
+
+include(Compiler/CMakeCommonCompilerMacros)
+
+if(CMAKE_HOST_WIN32)
+  # MSVC-like
+  macro(__compiler_intel lang)
+    if("x${lang}" STREQUAL "xFortran")
+      set(CMAKE_${lang}_COMPILE_OPTIONS_WARNING_AS_ERROR "-warn:errors")
+    else()
+      set(CMAKE_${lang}_COMPILE_OPTIONS_WARNING_AS_ERROR "-Werror-all")
+    endif()
+  endmacro()
+else()
+  # GNU-like
+  macro(__compiler_intel lang)
+    set(CMAKE_${lang}_VERBOSE_FLAG "-v")
+
+    string(APPEND CMAKE_${lang}_FLAGS_INIT " ")
+    string(APPEND CMAKE_${lang}_FLAGS_DEBUG_INIT " -g")
+    string(APPEND CMAKE_${lang}_FLAGS_MINSIZEREL_INIT " -Os")
+    string(APPEND CMAKE_${lang}_FLAGS_RELEASE_INIT " -O3")
+    string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " -O2 -g")
+
+    # Compiler + IPO does not recognize --dependency-file link option
+    set(CMAKE_${lang}_LINKER_DEPFILE_SUPPORTED FALSE)
+
+    if("${lang}" STREQUAL "CXX")
+      set(CMAKE_${lang}_COMPILER_PREDEFINES_COMMAND "${CMAKE_${lang}_COMPILER}")
+      if(CMAKE_${lang}_COMPILER_ARG1)
+        separate_arguments(_COMPILER_ARGS NATIVE_COMMAND "${CMAKE_${lang}_COMPILER_ARG1}")
+        list(APPEND CMAKE_${lang}_COMPILER_PREDEFINES_COMMAND ${_COMPILER_ARGS})
+        unset(_COMPILER_ARGS)
+      endif()
+      list(APPEND CMAKE_${lang}_COMPILER_PREDEFINES_COMMAND "-QdM" "-P" "-Za" "${CMAKE_ROOT}/Modules/CMakeCXXCompilerABI.cpp")
+    endif()
+
+    if("x${lang}" STREQUAL "xFortran")
+      set(CMAKE_${lang}_COMPILE_OPTIONS_WARNING_AS_ERROR "-warn" "errors")
+    else()
+      # Precompile Headers
+      set(CMAKE_PCH_EXTENSION .pchi)
+      set(CMAKE_LINK_PCH ON)
+      set(CMAKE_PCH_EPILOGUE "#pragma hdrstop")
+      set(CMAKE_${lang}_COMPILE_OPTIONS_INVALID_PCH -Winvalid-pch)
+      set(CMAKE_${lang}_COMPILE_OPTIONS_USE_PCH -Wno-pch-messages -pch-use <PCH_FILE> -include <PCH_HEADER>)
+      set(CMAKE_${lang}_COMPILE_OPTIONS_CREATE_PCH -Wno-pch-messages -pch-create <PCH_FILE> -include <PCH_HEADER>)
+
+      # COMPILE_WARNING_AS_ERROR
+      set(CMAKE_${lang}_COMPILE_OPTIONS_WARNING_AS_ERROR "-Werror-all")
+    endif()
+  endmacro()
+endif()

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/IntelLLVM-ASM.cmake

@@ -0,0 +1,12 @@
+include(Compiler/IntelLLVM)
+__compiler_intel_llvm(ASM)
+
+string(APPEND CMAKE_ASM_FLAGS_MINSIZEREL_INIT " -DNDEBUG")
+string(APPEND CMAKE_ASM_FLAGS_RELEASE_INIT " -DNDEBUG")
+string(APPEND CMAKE_ASM_FLAGS_RELWITHDEBINFO_INIT " -DNDEBUG")
+
+if(UNIX)
+  set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s;S)
+else()
+  set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS asm)
+endif()

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/IntelLLVM-CXX.cmake

@@ -0,0 +1,103 @@
+include(Compiler/IntelLLVM)
+__compiler_intel_llvm(CXX)
+
+if("x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC")
+  set(CMAKE_CXX_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -TP)
+  set(CMAKE_CXX_CLANG_TIDY_DRIVER_MODE "cl")
+  set(CMAKE_CXX_INCLUDE_WHAT_YOU_USE_DRIVER_MODE "cl")
+  if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+      AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
+      AND CMAKE_DEPFILE_FLAGS_CXX)
+    set(CMAKE_CXX_DEPENDS_USE_COMPILER TRUE)
+  endif()
+else()
+  set(CMAKE_CXX_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x c++)
+  if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+      AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
+      AND CMAKE_DEPFILE_FLAGS_CXX)
+    # dependencies are computed by the compiler itself
+    set(CMAKE_CXX_DEPFILE_FORMAT gcc)
+    set(CMAKE_CXX_DEPENDS_USE_COMPILER TRUE)
+  endif()
+
+  set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden")
+
+  string(APPEND CMAKE_CXX_FLAGS_MINSIZEREL_INIT " -DNDEBUG")
+  string(APPEND CMAKE_CXX_FLAGS_RELEASE_INIT " -DNDEBUG")
+  string(APPEND CMAKE_CXX_FLAGS_RELWITHDEBINFO_INIT " -DNDEBUG")
+endif()
+
+set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON)
+set(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT ON)
+set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON)
+
+if(NOT "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")
+  set(CMAKE_CXX98_STANDARD_COMPILE_OPTION  "-std=c++98")
+  set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "-std=gnu++98")
+
+  set(CMAKE_CXX11_STANDARD_COMPILE_OPTION  "-std=c++11")
+  set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=gnu++11")
+
+  set(CMAKE_CXX14_STANDARD_COMPILE_OPTION  "-std=c++14")
+  set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++14")
+
+  set(CMAKE_CXX17_STANDARD_COMPILE_OPTION  "-std=c++17")
+  set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++17")
+
+  set(CMAKE_CXX20_STANDARD_COMPILE_OPTION  "-std=c++20")
+  set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++20")
+
+  set(CMAKE_CXX_STANDARD_LATEST 20)
+
+  if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 2024.0.0)
+    set(CMAKE_CXX23_STANDARD_COMPILE_OPTION "-std=c++23")
+    set(CMAKE_CXX23_EXTENSION_COMPILE_OPTION "-std=gnu++23")
+    set(CMAKE_CXX_STANDARD_LATEST 23)
+  elseif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 2021.2.0)
+    set(CMAKE_CXX23_STANDARD_COMPILE_OPTION  "-std=c++2b")
+    set(CMAKE_CXX23_EXTENSION_COMPILE_OPTION "-std=gnu++2b")
+    set(CMAKE_CXX_STANDARD_LATEST 23)
+  endif()
+
+  if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 2024.0.0)
+    set(CMAKE_CXX26_STANDARD_COMPILE_OPTION "-std=c++26")
+    set(CMAKE_CXX26_EXTENSION_COMPILE_OPTION "-std=gnu++26")
+    set(CMAKE_CXX_STANDARD_LATEST 26)
+  endif()
+else()
+  set(CMAKE_CXX98_STANDARD_COMPILE_OPTION  "")
+  set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "")
+
+  set(CMAKE_CXX11_STANDARD_COMPILE_OPTION  "")
+  set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "")
+
+  set(CMAKE_CXX14_STANDARD_COMPILE_OPTION  "-Qstd:c++14")
+  set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-Qstd:c++14")
+
+  set(CMAKE_CXX17_STANDARD_COMPILE_OPTION  "-Qstd:c++17")
+  set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-Qstd:c++17")
+
+  set(CMAKE_CXX20_STANDARD_COMPILE_OPTION  "-Qstd:c++20")
+  set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-Qstd:c++20")
+
+  set(CMAKE_CXX_STANDARD_LATEST 20)
+
+  if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 2024.0.0)
+    set(CMAKE_CXX23_STANDARD_COMPILE_OPTION "-Qstd=c++23")
+    set(CMAKE_CXX23_EXTENSION_COMPILE_OPTION "-Qstd=c++23")
+    set(CMAKE_CXX_STANDARD_LATEST 23)
+  elseif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 2021.2.0)
+    set(CMAKE_CXX23_STANDARD_COMPILE_OPTION  "-Qstd:c++2b")
+    set(CMAKE_CXX23_EXTENSION_COMPILE_OPTION "-Qstd:c++2b")
+    set(CMAKE_CXX_STANDARD_LATEST 23)
+  endif()
+
+  if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 2024.0.0)
+    set(CMAKE_CXX26_STANDARD_COMPILE_OPTION "-Qstd=c++26")
+    set(CMAKE_CXX26_EXTENSION_COMPILE_OPTION "-Qstd=c++26")
+    set(CMAKE_CXX_STANDARD_LATEST 26)
+  endif()
+
+endif()
+
+__compiler_check_default_language_standard(CXX 2020 14)

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/LCC-Fortran.cmake

@@ -0,0 +1,29 @@
+include(Compiler/LCC)
+__compiler_lcc(Fortran)
+
+set(CMAKE_Fortran_SUBMODULE_SEP "@")
+set(CMAKE_Fortran_SUBMODULE_EXT ".smod")
+
+set(CMAKE_Fortran_PREPROCESS_SOURCE
+  "<CMAKE_Fortran_COMPILER> -cpp <DEFINES> <INCLUDES> <FLAGS> -E <SOURCE> -o <PREPROCESSED_SOURCE>")
+
+set(CMAKE_Fortran_FORMAT_FIXED_FLAG "-ffixed-form")
+set(CMAKE_Fortran_FORMAT_FREE_FLAG "-ffree-form")
+
+# LCC < 1.24.00 has a broken Fortran preprocessor
+if(CMAKE_Fortran_COMPILER_VERSION VERSION_GREATER_EQUAL "1.24.00")
+  set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_ON "-cpp")
+  set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_OFF "-nocpp")
+endif()
+
+set(CMAKE_Fortran_POSTPROCESS_FLAG "-fpreprocessed")
+
+# No -DNDEBUG for Fortran.
+string(APPEND CMAKE_Fortran_FLAGS_MINSIZEREL_INIT " -Os")
+string(APPEND CMAKE_Fortran_FLAGS_RELEASE_INIT " -O3")
+
+# No -isystem for Fortran because it will not find .mod files.
+unset(CMAKE_INCLUDE_SYSTEM_FLAG_Fortran)
+
+# Fortran-specific feature flags.
+set(CMAKE_Fortran_MODDIR_FLAG -J)

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/MSVC-CXX-CXXImportStd.cmake

@@ -0,0 +1,115 @@
+function (_cmake_cxx_import_std std variable)
+  find_file(_msvc_modules_json_file
+    NAME modules.json
+    HINTS
+      "$ENV{VCToolsInstallDir}/modules"
+    PATHS
+      "$ENV{INCLUDE}"
+      "${CMAKE_CXX_COMPILER}/../../.."
+      "${CMAKE_CXX_COMPILER}/../.."    # msvc-wine layout
+    PATH_SUFFIXES
+      ../modules
+    NO_CACHE)
+  # Without this file, we do not have modules installed.
+  if (NOT EXISTS "${_msvc_modules_json_file}")
+    set("${variable}"
+      "set(CMAKE_CXX${std}_COMPILER_IMPORT_STD_NOT_FOUND_MESSAGE \"Could not find `modules.json` resource\")\n"
+      PARENT_SCOPE)
+    return ()
+  endif ()
+
+  file(READ "${_msvc_modules_json_file}" _msvc_modules_json)
+  string(JSON _msvc_json_version GET "${_msvc_modules_json}" "version")
+  string(JSON _msvc_json_revision GET "${_msvc_modules_json}" "revision")
+  # Require version 1.
+  if (NOT _msvc_json_version EQUAL "1")
+    set("${variable}"
+      "set(CMAKE_CXX${std}_COMPILER_IMPORT_STD_NOT_FOUND_MESSAGE \"`modules.json` version ${_msvc_json_version}.${_msvc_json_revision} is not recognized\")\n"
+      PARENT_SCOPE)
+    return ()
+  endif ()
+
+  string(JSON _msvc_json_library GET "${_msvc_modules_json}" "library")
+  # Bail if we don't understand the library.
+  if (NOT _msvc_json_library STREQUAL "microsoft/STL")
+    set("${variable}"
+      "set(CMAKE_CXX${std}_COMPILER_IMPORT_STD_NOT_FOUND_MESSAGE \"`modules.json` library `${_msvc_json_library}` is not recognized\")\n"
+      PARENT_SCOPE)
+    return ()
+  endif ()
+
+  string(JSON _msvc_json_nmodules LENGTH "${_msvc_modules_json}" "module-sources")
+  # Don't declare the target without any modules.
+  if (NOT _msvc_json_nmodules)
+    set("${variable}"
+      "set(CMAKE_CXX${std}_COMPILER_IMPORT_STD_NOT_FOUND_MESSAGE \"`modules.json` does not list any available modules\")\n"
+      PARENT_SCOPE)
+    return ()
+  endif ()
+
+  # Declare the target.
+  set(_msvc_std_target "")
+  string(APPEND _msvc_std_target
+    "add_library(__cmake_cxx${std} STATIC)\n")
+  string(APPEND _msvc_std_target
+    "target_sources(__cmake_cxx${std} INTERFACE \"$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,STATIC_LIBRARY>:$<TARGET_OBJECTS:__cmake_cxx${std}>>\")\n")
+  string(APPEND _msvc_std_target
+    "set_property(TARGET __cmake_cxx${std} PROPERTY EXCLUDE_FROM_ALL 1)\n")
+  string(APPEND _msvc_std_target
+    "set_property(TARGET __cmake_cxx${std} PROPERTY CXX_SCAN_FOR_MODULES 1)\n")
+  string(APPEND _msvc_std_target
+    "set_property(TARGET __cmake_cxx${std} PROPERTY CXX_MODULE_STD 0)\n")
+  string(APPEND _msvc_std_target
+    "target_compile_features(__cmake_cxx${std} PUBLIC cxx_std_${std})\n")
+
+  set(_msvc_modules_module_paths "")
+  get_filename_component(_msvc_modules_dir "${_msvc_modules_json_file}" DIRECTORY)
+
+  # Add module sources.
+  math(EXPR _msvc_modules_json_nmodules_range "${_msvc_json_nmodules} - 1")
+  foreach (_msvc_modules_json_modules_idx RANGE 0 "${_msvc_modules_json_nmodules_range}")
+    string(JSON _msvc_modules_json_module_source GET "${_msvc_modules_json}" "module-sources" "${_msvc_modules_json_modules_idx}")
+
+    if (NOT IS_ABSOLUTE "${_msvc_modules_json_module_source}")
+      string(PREPEND _msvc_modules_json_module_source "${_msvc_modules_dir}/")
+    endif ()
+    list(APPEND _msvc_modules_module_paths
+      "${_msvc_modules_json_module_source}")
+  endforeach ()
+
+  # Split the paths into basedirs and module paths.
+  set(_msvc_modules_base_dirs_list "")
+  set(_msvc_modules_files "")
+  foreach (_msvc_modules_module_path IN LISTS _msvc_modules_module_paths)
+    get_filename_component(_msvc_module_dir "${_msvc_modules_module_path}" DIRECTORY)
+
+    list(APPEND _msvc_modules_base_dirs_list
+      "${_msvc_module_dir}")
+    string(APPEND _msvc_modules_files
+      " \"${_msvc_modules_module_path}\"")
+  endforeach ()
+  list(REMOVE_DUPLICATES _msvc_modules_base_dirs_list)
+  set(_msvc_modules_base_dirs "")
+  foreach (_msvc_modules_base_dir IN LISTS _msvc_modules_base_dirs_list)
+    string(APPEND _msvc_modules_base_dirs
+      " \"${_msvc_modules_base_dir}\"")
+  endforeach ()
+
+  # Create the file set for the modules.
+  string(APPEND _msvc_std_target
+    "target_sources(__cmake_cxx${std}
+  PUBLIC
+  FILE_SET std TYPE CXX_MODULES
+    BASE_DIRS ${_msvc_modules_base_dirs}
+    FILES ${_msvc_modules_files})\n")
+
+  # Wrap the `__cmake_cxx${std}` target in a check.
+  string(PREPEND _msvc_std_target
+    "if (NOT TARGET \"__cmake_cxx${std}\")\n")
+  string(APPEND _msvc_std_target
+    "endif ()\n")
+  string(APPEND _msvc_std_target
+    "add_library(__CMAKE::CXX${std} ALIAS __cmake_cxx${std})\n")
+
+  set("${variable}" "${_msvc_std_target}" PARENT_SCOPE)
+endfunction ()

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/MSVC-CXX-FeatureTests.cmake

@@ -0,0 +1,109 @@
+# Reference: https://docs.microsoft.com/en-us/cpp/visual-cpp-language-conformance
+# https://blogs.msdn.microsoft.com/vcblog/2015/06/19/c111417-features-in-vs-2015-rtm/
+# https://blogs.msdn.microsoft.com/vcblog/2013/12/02/c1114-core-language-features-in-vs-2013-and-the-nov-2013-ctp/
+# https://blogs.msdn.microsoft.com/vcblog/2011/09/12/c11-features-in-visual-c-11/
+
+set(_cmake_oldestSupported "_MSC_VER >= 1600")
+
+# VS 2017 v15.3 fixes support for incomplete decltypes
+# https://docs.microsoft.com/en-us/cpp/cpp-conformance-improvements-2017#update_153
+set(_cmake_feature_test_cxx_decltype_incomplete_return_types "_MSC_VER >= 1911")
+
+# VS 2017 v15.3 fixes support for "N3652 Extended constexpr"
+set(_cmake_feature_test_cxx_relaxed_constexpr "_MSC_VER >= 1911")
+
+# VS 2017 Preview introduces support for aggregate initializers.
+set(_cmake_feature_test_cxx_aggregate_default_initializers "_MSC_FULL_VER >= 190024406")
+
+# VS 2015 Update 2 introduces support for variable templates.
+# https://www.visualstudio.com/en-us/news/vs2015-update2-vs.aspx
+set(_cmake_feature_test_cxx_variable_templates "_MSC_FULL_VER >= 190023918")
+
+set(MSVC_2015 "_MSC_VER >= 1900")
+set(_cmake_feature_test_cxx_alignas "${MSVC_2015}")
+set(_cmake_feature_test_cxx_alignof "${MSVC_2015}")
+set(_cmake_feature_test_cxx_attributes "${MSVC_2015}")
+set(_cmake_feature_test_cxx_attribute_deprecated "${MSVC_2015}")
+set(_cmake_feature_test_cxx_binary_literals "${MSVC_2015}")
+set(_cmake_feature_test_cxx_constexpr "${MSVC_2015}")
+set(_cmake_feature_test_cxx_decltype_auto "${MSVC_2015}")
+set(_cmake_feature_test_cxx_digit_separators "${MSVC_2015}")
+set(_cmake_feature_test_cxx_func_identifier "${MSVC_2015}")
+set(_cmake_feature_test_cxx_nonstatic_member_init "${MSVC_2015}")
+# Microsoft calls this 'rvalue references v3'
+set(_cmake_feature_test_cxx_defaulted_move_initializers "${MSVC_2015}")
+set(_cmake_feature_test_cxx_generic_lambdas "${MSVC_2015}")
+set(_cmake_feature_test_cxx_inheriting_constructors "${MSVC_2015}")
+set(_cmake_feature_test_cxx_inline_namespaces "${MSVC_2015}")
+set(_cmake_feature_test_cxx_lambda_init_captures "${MSVC_2015}")
+set(_cmake_feature_test_cxx_noexcept "${MSVC_2015}")
+set(_cmake_feature_test_cxx_return_type_deduction "${MSVC_2015}")
+set(_cmake_feature_test_cxx_sizeof_member "${MSVC_2015}")
+set(_cmake_feature_test_cxx_thread_local "${MSVC_2015}")
+set(_cmake_feature_test_cxx_unicode_literals "${MSVC_2015}")
+set(_cmake_feature_test_cxx_unrestricted_unions "${MSVC_2015}")
+set(_cmake_feature_test_cxx_user_literals "${MSVC_2015}")
+set(_cmake_feature_test_cxx_reference_qualified_functions "${MSVC_2015}")
+# "The copies and moves don't interact precisely like the Standard says they
+# should. For example, deletion of moves is specified to also suppress
+# copies, but Visual C++ in Visual Studio 2013 does not."
+# http://blogs.msdn.com/b/vcblog/archive/2014/11/17/c-11-14-17-features-in-vs-2015-preview.aspx
+# lists this as 'partial' in 2013
+set(_cmake_feature_test_cxx_deleted_functions "${MSVC_2015}")
+
+# http://blogs.msdn.com/b/vcblog/archive/2014/11/17/c-11-14-17-features-in-vs-2015-preview.aspx
+# Note 1. While previous version of VisualStudio said they supported these
+# they silently produced bad code, and are now marked as having partial
+# support in previous versions. The footnote says the support will be complete
+# in MSVC 2015, so support the feature for that version, assuming that is true.
+# The blog post also says that VS 2013 Update 3 generates an error in cases
+# that previously produced bad code.
+set(_cmake_feature_test_cxx_generalized_initializers "_MSC_FULL_VER >= 180030723")
+
+set(MSVC_2013 "_MSC_VER >= 1800")
+set(_cmake_feature_test_cxx_alias_templates "${MSVC_2013}")
+# Microsoft now states they support contextual conversions in 2013 and above.
+# See footnote 6 at:
+# http://blogs.msdn.com/b/vcblog/archive/2014/11/17/c-11-14-17-features-in-vs-2015-preview.aspx
+set(_cmake_feature_test_cxx_contextual_conversions "${MSVC_2013}")
+set(_cmake_feature_test_cxx_default_function_template_args "${MSVC_2013}")
+set(_cmake_feature_test_cxx_defaulted_functions "${MSVC_2013}")
+set(_cmake_feature_test_cxx_delegating_constructors "${MSVC_2013}")
+set(_cmake_feature_test_cxx_explicit_conversions "${MSVC_2013}")
+set(_cmake_feature_test_cxx_raw_string_literals "${MSVC_2013}")
+set(_cmake_feature_test_cxx_uniform_initialization "${MSVC_2013}")
+# Support is documented, but possibly partly broken:
+# https://msdn.microsoft.com/en-us/library/hh567368.aspx
+# http://thread.gmane.org/gmane.comp.lib.boost.devel/244986/focus=245333
+set(_cmake_feature_test_cxx_variadic_templates "${MSVC_2013}")
+
+set(MSVC_2012 "_MSC_VER >= 1700")
+set(_cmake_feature_test_cxx_enum_forward_declarations "${MSVC_2012}")
+set(_cmake_feature_test_cxx_final "${MSVC_2012}")
+set(_cmake_feature_test_cxx_range_for "${MSVC_2012}")
+set(_cmake_feature_test_cxx_strong_enums "${MSVC_2012}")
+
+set(MSVC_2010 "_MSC_VER >= 1600")
+set(_cmake_feature_test_cxx_auto_type "${MSVC_2010}")
+set(_cmake_feature_test_cxx_decltype "${MSVC_2010}")
+set(_cmake_feature_test_cxx_extended_friend_declarations "${MSVC_2010}")
+set(_cmake_feature_test_cxx_extern_templates "${MSVC_2010}")
+set(_cmake_feature_test_cxx_lambdas "${MSVC_2010}")
+set(_cmake_feature_test_cxx_local_type_template_args "${MSVC_2010}")
+set(_cmake_feature_test_cxx_long_long_type "${MSVC_2010}")
+set(_cmake_feature_test_cxx_nullptr "${MSVC_2010}")
+set(_cmake_feature_test_cxx_override "${MSVC_2010}")
+set(_cmake_feature_test_cxx_right_angle_brackets "${MSVC_2010}")
+set(_cmake_feature_test_cxx_rvalue_references "${MSVC_2010}")
+set(_cmake_feature_test_cxx_static_assert "${MSVC_2010}")
+set(_cmake_feature_test_cxx_template_template_parameters "${MSVC_2010}")
+set(_cmake_feature_test_cxx_trailing_return_types "${MSVC_2010}")
+set(_cmake_feature_test_cxx_variadic_macros "${MSVC_2010}")
+
+# Unset all the variables that we don't need exposed.
+# _cmake_oldestSupported is required by WriteCompilerDetectionHeader
+set(MSVC_2017)
+set(MSVC_2015)
+set(MSVC_2013)
+set(MSVC_2012)
+set(MSVC_2010)

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/MSVC-CXX.cmake

@@ -0,0 +1,103 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Compiler/MSVC)
+__compiler_msvc(CXX)
+
+include(Compiler/CMakeCommonCompilerMacros)
+
+if ((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 19.0.24215.1 AND
+     CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.10) OR
+   CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 19.10.25017)
+
+  # VS 2015 Update 3 and above support language standard level flags,
+  # with the default and minimum level being C++14.
+  set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "")
+  set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "")
+  set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON)
+  set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "")
+  set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "")
+  set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std:c++14")
+  set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std:c++14")
+
+  if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 19.11.25505)
+    set(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT ON)
+    set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON)
+    set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std:c++17")
+    set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std:c++17")
+  else()
+    set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std:c++latest")
+    set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std:c++latest")
+  endif()
+
+  set(CMAKE_CXX_STANDARD_LATEST 17)
+
+  if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 19.29.30129)
+    set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std:c++20")
+    set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std:c++20")
+    set(CMAKE_CXX23_STANDARD_COMPILE_OPTION "-std:c++latest")
+    set(CMAKE_CXX23_EXTENSION_COMPILE_OPTION "-std:c++latest")
+    set(CMAKE_CXX_STANDARD_LATEST 23)
+  elseif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 19.12.25835)
+    set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std:c++latest")
+    set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std:c++latest")
+    set(CMAKE_CXX_STANDARD_LATEST 20)
+  endif()
+
+  __compiler_check_default_language_standard(CXX 19.0 14)
+
+elseif (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0)
+  # MSVC has no specific options to set language standards, but set them as
+  # empty strings anyways so the feature test infrastructure can at least check
+  # to see if they are defined.
+  set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "")
+  set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "")
+  set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "")
+  set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "")
+  set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "")
+  set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "")
+  set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "")
+  set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "")
+  set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "")
+  set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "")
+
+  if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 19.0)
+    set(CMAKE_CXX_STANDARD_LATEST 17)
+  elseif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 18.0)
+    set(CMAKE_CXX_STANDARD_LATEST 14)
+  else()
+    set(CMAKE_CXX_STANDARD_LATEST 11)
+  endif()
+
+  # There is no meaningful default for this
+  set(CMAKE_CXX_STANDARD_DEFAULT "")
+
+  # There are no compiler modes so we only need to test features once.
+  # Override the default macro for this special case.  Pretend that
+  # all language standards are available so that at least compilation
+  # can be attempted.
+  macro(cmake_record_cxx_compile_features)
+    list(APPEND CMAKE_CXX_COMPILE_FEATURES
+      cxx_std_98
+      cxx_std_11
+      cxx_std_14
+      cxx_std_17
+      cxx_std_20
+      cxx_std_23
+      cxx_std_26
+      )
+    _record_compiler_features(CXX "" CMAKE_CXX_COMPILE_FEATURES)
+  endmacro()
+endif()
+
+if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "19.34")
+  string(CONCAT CMAKE_CXX_SCANDEP_SOURCE
+    "<CMAKE_CXX_COMPILER> <DEFINES> <INCLUDES> <FLAGS> <SOURCE> -nologo -TP"
+    " -showIncludes"
+    " -scanDependencies <DYNDEP_FILE>"
+    " -Fo<OBJECT>")
+  set(CMAKE_CXX_SCANDEP_DEPFILE_FORMAT "msvc")
+  set(CMAKE_CXX_MODULE_MAP_FORMAT "msvc")
+  set(CMAKE_CXX_MODULE_MAP_FLAG "@<MODULE_MAP_FILE>")
+  set(CMAKE_CXX_MODULE_BMI_ONLY_FLAG "-ifcOnly;-ifcOutput;<OBJECT>")
+endif ()

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/MSVC.cmake

@@ -0,0 +1,25 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# This module is shared by multiple languages; use include blocker.
+if(__COMPILER_MSVC)
+  return()
+endif()
+set(__COMPILER_MSVC 1)
+
+macro(__compiler_msvc lang)
+  set(CMAKE_${lang}_CLANG_TIDY_DRIVER_MODE "cl")
+  set(CMAKE_${lang}_INCLUDE_WHAT_YOU_USE_DRIVER_MODE "cl")
+  set(CMAKE_${lang}_COMPILE_OPTIONS_WARNING_AS_ERROR "-WX")
+
+  # /JMC "Just My Code" is only supported by MSVC 19.05 onward.
+  if (CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL 19.05)
+    set(CMAKE_${lang}_COMPILE_OPTIONS_JMC "-JMC")
+  endif()
+
+  # The `/external:I` flag was made non-experimental in 19.29.30036.3.
+  if (CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL 19.29.30036.3)
+    set(CMAKE_INCLUDE_SYSTEM_FLAG_${lang} "-external:I")
+    set(CMAKE_INCLUDE_SYSTEM_FLAG_${lang}_WARNING "-external:W0 ")
+  endif ()
+endmacro()

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/NAG-Fortran.cmake

@@ -0,0 +1,51 @@
+# Help CMAKE_PARSE_IMPLICIT_LINK_INFO detect NAG Fortran object files.
+if(NOT CMAKE_Fortran_COMPILER_WORKS AND NOT CMAKE_Fortran_COMPILER_FORCED)
+  message(CHECK_START "Detecting NAG Fortran directory")
+  # Run with -dryrun to see sample "link" line.
+  execute_process(
+    COMMAND ${CMAKE_Fortran_COMPILER} dummy.o -dryrun
+    OUTPUT_VARIABLE _dryrun
+    ERROR_VARIABLE _dryrun
+    )
+  # Match an object file.
+  string(REGEX MATCH "/[^ ]*/[^ /][^ /]*\\.o" _nag_obj "${_dryrun}")
+  if(_nag_obj)
+    # Parse object directory and convert to a regex.
+    string(REGEX REPLACE "/[^/]*$" "" _nag_dir "${_nag_obj}")
+    string(REGEX REPLACE "([][+.*()^])" "\\\\\\1" _nag_regex "${_nag_dir}")
+    set(CMAKE_Fortran_IMPLICIT_OBJECT_REGEX "^${_nag_regex}/")
+    message(CONFIGURE_LOG
+      "Detecting NAG Fortran directory with -dryrun found\n"
+      "  object: ${_nag_obj}\n"
+      "  directory: ${_nag_dir}\n"
+      "  regex: ${CMAKE_Fortran_IMPLICIT_OBJECT_REGEX}\n"
+      "from output:\n${_dryrun}\n\n")
+    message(CHECK_PASS "${_nag_dir}")
+  else()
+    message(CONFIGURE_LOG
+      "Detecting NAG Fortran directory with -dryrun failed:\n${_dryrun}\n\n")
+    message(CHECK_FAIL "failed")
+  endif()
+endif()
+
+# Initial configuration flags.
+string(APPEND CMAKE_Fortran_FLAGS_INIT " ")
+string(APPEND CMAKE_Fortran_FLAGS_DEBUG_INIT " -g")
+string(APPEND CMAKE_Fortran_FLAGS_MINSIZEREL_INIT " -O2 -DNDEBUG")
+string(APPEND CMAKE_Fortran_FLAGS_RELEASE_INIT " -O4 -DNDEBUG")
+string(APPEND CMAKE_Fortran_FLAGS_RELWITHDEBINFO_INIT " -O2 -g -DNDEBUG")
+
+set(CMAKE_Fortran_SUBMODULE_SEP ".")
+set(CMAKE_Fortran_SUBMODULE_EXT ".sub")
+set(CMAKE_Fortran_MODDIR_FLAG "-mdir ")
+set(CMAKE_Fortran_MODDIR_INCLUDE_FLAG "-I") # -mdir does not affect search path
+set(CMAKE_SHARED_LIBRARY_Fortran_FLAGS "-PIC")
+set(CMAKE_Fortran_FORMAT_FIXED_FLAG "-fixed")
+set(CMAKE_Fortran_FORMAT_FREE_FLAG "-free")
+set(CMAKE_Fortran_COMPILE_OPTIONS_PIC "-PIC")
+set(CMAKE_Fortran_COMPILE_OPTIONS_PIE "-PIC")
+set(CMAKE_Fortran_RESPONSE_FILE_LINK_FLAG "-Wl,@")
+set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_ON "-fpp")
+
+set(CMAKE_Fortran_PREPROCESS_SOURCE
+  "<CMAKE_Fortran_COMPILER> -fpp <DEFINES> <INCLUDES> <FLAGS> -F <SOURCE> -o <PREPROCESSED_SOURCE>")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/NVHPC.cmake

@@ -0,0 +1,17 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+# This module is shared by multiple languages; use include blocker.
+if(__COMPILER_NVHPC)
+  return()
+endif()
+set(__COMPILER_NVHPC 1)
+
+include(Compiler/PGI)
+
+macro(__compiler_nvhpc lang)
+  # Logic specific to NVHPC.
+  set(CMAKE_INCLUDE_SYSTEM_FLAG_${lang} "-isystem ")
+  set(CMAKE_${lang}_COMPILE_OPTIONS_WARNING_AS_ERROR "-Werror")
+endmacro()

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/NVIDIA-CUDA.cmake

@@ -0,0 +1,23 @@
+include(Compiler/NVIDIA)
+__compiler_nvidia_cxx_standards(CUDA)
+__compiler_nvidia_cuda_flags(CUDA)
+
+set(CMAKE_CUDA_COMPILER_HAS_DEVICE_LINK_PHASE True)
+
+set(_CMAKE_CUDA_WHOLE_FLAG "-c")
+set(_CMAKE_CUDA_RDC_FLAG "-rdc=true")
+set(_CMAKE_CUDA_PTX_FLAG "-ptx")
+set(_CMAKE_CUDA_CUBIN_FLAG "-cubin")
+set(_CMAKE_CUDA_FATBIN_FLAG "-fatbin")
+if(CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL "11.7.0")
+  set(_CMAKE_CUDA_OPTIX_FLAG "-optix-ir")
+endif()
+
+if(CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 11.2)
+  set(CMAKE_CUDA_DEVICE_LINK_OPTIONS_IPO " -dlto")
+endif()
+
+set(CMAKE_CUDA_DEVICE_COMPILER_WRAPPER_FLAG "-Xcompiler=")
+set(CMAKE_CUDA_DEVICE_COMPILER_WRAPPER_FLAG_SEP ",")
+set(CMAKE_CUDA_DEVICE_LINKER_WRAPPER_FLAG "-Xlinker=")
+set(CMAKE_CUDA_DEVICE_LINKER_WRAPPER_FLAG_SEP ",")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/NVIDIA-DetermineCompiler.cmake

@@ -0,0 +1,29 @@
+
+set(_compiler_id_pp_test "defined(__NVCC__)")
+
+set(_compiler_id_version_compute "
+# if defined(__CUDACC_VER_MAJOR__)
+#  define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__CUDACC_VER_MAJOR__)
+#  define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__CUDACC_VER_MINOR__)
+#  define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__CUDACC_VER_BUILD__)
+# endif
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define @PREFIX@SIMULATE_VERSION_MAJOR @MACRO_DEC@(_MSC_VER / 100)
+#  define @PREFIX@SIMULATE_VERSION_MINOR @MACRO_DEC@(_MSC_VER % 100)
+# elif defined(__clang__)
+#  define @PREFIX@SIMULATE_VERSION_MAJOR @MACRO_DEC@(__clang_major__)
+#  define @PREFIX@SIMULATE_VERSION_MINOR @MACRO_DEC@(__clang_minor__)
+# elif defined(__GNUC__)
+#  define @PREFIX@SIMULATE_VERSION_MAJOR @MACRO_DEC@(__GNUC__)
+#  define @PREFIX@SIMULATE_VERSION_MINOR @MACRO_DEC@(__GNUC_MINOR__)
+# endif")
+
+set(_compiler_id_simulate "
+# if defined(_MSC_VER)
+#  define @PREFIX@SIMULATE_ID \"MSVC\"
+# elif defined(__clang__)
+#  define @PREFIX@SIMULATE_ID \"Clang\"
+# elif defined(__GNUC__)
+#  define @PREFIX@SIMULATE_ID \"GNU\"
+# endif")

mplug_owl2/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Compiler/NVIDIA.cmake

@@ -0,0 +1,180 @@
+
+# This module is shared by multiple languages; use include blocker.
+if(__COMPILER_NVIDIA)
+  return()
+endif()
+set(__COMPILER_NVIDIA 1)
+
+include(Compiler/CMakeCommonCompilerMacros)
+
+macro(__compiler_nvidia_cxx_standards lang)
+  if("x${CMAKE_${lang}_SIMULATE_ID}" STREQUAL "xMSVC")
+    # MSVC requires c++14 as the minimum level
+    set(CMAKE_${lang}03_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_${lang}03_EXTENSION_COMPILE_OPTION "")
+
+    # MSVC requires c++14 as the minimum level
+    set(CMAKE_${lang}11_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_${lang}11_EXTENSION_COMPILE_OPTION "")
+
+    set(CMAKE_${lang}_STANDARD_LATEST 11)
+
+    if (NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 9.0)
+      if(CMAKE_${lang}_SIMULATE_VERSION VERSION_GREATER_EQUAL 19.10.25017)
+        set(CMAKE_${lang}14_STANDARD_COMPILE_OPTION "-std=c++14")
+        set(CMAKE_${lang}14_EXTENSION_COMPILE_OPTION "-std=c++14")
+      else()
+        set(CMAKE_${lang}14_STANDARD_COMPILE_OPTION "")
+        set(CMAKE_${lang}14_EXTENSION_COMPILE_OPTION "")
+      endif()
+
+      set(CMAKE_${lang}_STANDARD_LATEST 14)
+    endif()
+
+    if (NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 11.0)
+      if(CMAKE_${lang}_SIMULATE_VERSION VERSION_GREATER_EQUAL 19.11.25505)
+        set(CMAKE_${lang}17_STANDARD_COMPILE_OPTION "-std=c++17")
+        set(CMAKE_${lang}17_EXTENSION_COMPILE_OPTION "-std=c++17")
+        set(CMAKE_${lang}_STANDARD_LATEST 17)
+      endif()
+    endif()
+
+    if (NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 12.0)
+      if(CMAKE_${lang}_SIMULATE_VERSION VERSION_GREATER_EQUAL 19.11.25505)
+        set(CMAKE_${lang}20_STANDARD_COMPILE_OPTION "-std=c++20")
+        set(CMAKE_${lang}20_EXTENSION_COMPILE_OPTION "-std=c++20")
+        set(CMAKE_${lang}_STANDARD_LATEST 20)
+      endif()
+    endif()
+  else()
+    set(CMAKE_${lang}03_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_${lang}03_EXTENSION_COMPILE_OPTION "")
+
+    set(CMAKE_${lang}11_STANDARD_COMPILE_OPTION "-std=c++11")
+    set(CMAKE_${lang}11_EXTENSION_COMPILE_OPTION "-std=c++11")
+
+    set(CMAKE_${lang}_STANDARD_LATEST 11)
+
+    if (NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 9.0)
+      set(CMAKE_${lang}03_STANDARD_COMPILE_OPTION "-std=c++03")
+      set(CMAKE_${lang}03_EXTENSION_COMPILE_OPTION "-std=c++03")
+      set(CMAKE_${lang}14_STANDARD_COMPILE_OPTION "-std=c++14")
+      set(CMAKE_${lang}14_EXTENSION_COMPILE_OPTION "-std=c++14")
+
+      set(CMAKE_${lang}_STANDARD_LATEST 14)
+    endif()
+
+    if (NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 11.0)
+      set(CMAKE_${lang}17_STANDARD_COMPILE_OPTION "-std=c++17")
+      set(CMAKE_${lang}17_EXTENSION_COMPILE_OPTION "-std=c++17")
+      set(CMAKE_${lang}_STANDARD_LATEST 17)
+    endif()
+
+    if (NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 12.0)
+      set(CMAKE_${lang}20_STANDARD_COMPILE_OPTION "-std=c++20")
+      set(CMAKE_${lang}20_EXTENSION_COMPILE_OPTION "-std=c++20")
+      set(CMAKE_${lang}_STANDARD_LATEST 20)
+    endif()
+  endif()
+
+  __compiler_check_default_language_standard(${lang} 6.0 03)
+endmacro()
+
+macro(__compiler_nvidia_cuda_flags lang)
+  set(CMAKE_${lang}_VERBOSE_FLAG "-v")
+  set(CMAKE_${lang}_VERBOSE_COMPILE_FLAG "-Xcompiler=-v")
+  set(_CMAKE_COMPILE_AS_${lang}_FLAG "-x cu")
+
+  if (CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL 10.2.89)
+    # The -forward-unknown-to-host-compiler flag was only
+    # added to nvcc in 10.2 so before that we had no good
+    # way to invoke the NVCC compiler and propagate unknown
+    # flags such as -pthread to the host compiler
+    set(_CMAKE_${lang}_EXTRA_FLAGS "-forward-unknown-to-host-compiler")
+  else()
+    set(_CMAKE_${lang}_EXTRA_FLAGS "")
+  endif()
+
+  if(CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL "8.0.0")
+    set(_CMAKE_${lang}_EXTRA_DEVICE_LINK_FLAGS "-Wno-deprecated-gpu-targets")
+  else()
+    set(_CMAKE_${lang}_EXTRA_DEVICE_LINK_FLAGS "")
+  endif()
+
+  if(CMAKE_${lang}_HOST_COMPILER AND NOT CMAKE_GENERATOR MATCHES "Visual Studio")
+    string(APPEND _CMAKE_${lang}_EXTRA_FLAGS " -ccbin=<CMAKE_${lang}_HOST_COMPILER>")
+  endif()
+
+  if (CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL 10.2.89)
+    # Starting in 10.2, nvcc supported treating all warnings as errors
+    set(CMAKE_${lang}_COMPILE_OPTIONS_WARNING_AS_ERROR "-Werror" "all-warnings")
+  endif()
+
+  set(CMAKE_${lang}_DEPFILE_FORMAT gcc)
+  if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+      AND CMAKE_GENERATOR MATCHES "Makefiles|WMake")
+    set(CMAKE_${lang}_DEPENDS_USE_COMPILER TRUE)
+  endif()
+
+  if (CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL 10.2.89)
+    # The -MD flag was only added to nvcc in 10.2 so
+    # before that we had to invoke the compiler twice
+    # to get header dependency information
+    set(CMAKE_DEPFILE_FLAGS_${lang} "-MD -MT <DEP_TARGET> -MF <DEP_FILE>")
+  else()
+    set(CMAKE_${lang}_DEPENDS_EXTRA_COMMANDS "<CMAKE_${lang}_COMPILER> ${_CMAKE_${lang}_EXTRA_FLAGS} <DEFINES> <INCLUDES> <FLAGS> ${_CMAKE_COMPILE_AS_${lang}_FLAG} -M <SOURCE> -MT <OBJECT> -o <DEP_FILE>")
+  endif()
+
+  if(CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL 11.2)
+    set(_CMAKE_${lang}_IPO_SUPPORTED_BY_CMAKE YES)
+    set(_CMAKE_${lang}_IPO_MAY_BE_SUPPORTED_BY_COMPILER YES)
+  endif()
+
+  if(NOT "x${CMAKE_${lang}_SIMULATE_ID}" STREQUAL "xMSVC")
+    set(CMAKE_${lang}_COMPILE_OPTIONS_PIE -Xcompiler=-fPIE)
+    set(CMAKE_${lang}_COMPILE_OPTIONS_PIC -Xcompiler=-fPIC)
+    set(CMAKE_${lang}_COMPILE_OPTIONS_VISIBILITY -Xcompiler=-fvisibility=)
+    # CMAKE_SHARED_LIBRARY_${lang}_FLAGS is sent to the host linker so we
+    # don't need to forward it through nvcc.
+    set(CMAKE_SHARED_LIBRARY_${lang}_FLAGS -fPIC)
+    string(APPEND CMAKE_${lang}_FLAGS_INIT " ")
+    string(APPEND CMAKE_${lang}_FLAGS_DEBUG_INIT " -g")
+    string(APPEND CMAKE_${lang}_FLAGS_RELEASE_INIT " -O3 -DNDEBUG")
+    string(APPEND CMAKE_${lang}_FLAGS_MINSIZEREL_INIT " -O1 -DNDEBUG")
+    string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " -O2 -g -DNDEBUG")
+  endif()
+
+  set(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS -shared)
+  set(CMAKE_INCLUDE_SYSTEM_FLAG_${lang} "-isystem ")
+
+  if (CMAKE_${lang}_SIMULATE_ID STREQUAL "GNU")
+    set(CMAKE_${lang}_LINKER_WRAPPER_FLAG "-Wl,")
+    set(CMAKE_${lang}_LINKER_WRAPPER_FLAG_SEP ",")
+  elseif(CMAKE_${lang}_SIMULATE_ID STREQUAL "Clang")
+    set(CMAKE_${lang}_LINKER_WRAPPER_FLAG "-Xlinker" " ")
+    set(CMAKE_${lang}_LINKER_WRAPPER_FLAG_SEP)
+  endif()
+
+  set(CMAKE_${lang}_RUNTIME_LIBRARY_LINK_OPTIONS_STATIC  "cudadevrt;cudart_static")
+  set(CMAKE_${lang}_RUNTIME_LIBRARY_LINK_OPTIONS_SHARED  "cudadevrt;cudart")
+  set(CMAKE_${lang}_RUNTIME_LIBRARY_LINK_OPTIONS_NONE    "")
+
+  if(UNIX AND NOT (CMAKE_SYSTEM_NAME STREQUAL "QNX"))
+    list(APPEND CMAKE_${lang}_RUNTIME_LIBRARY_LINK_OPTIONS_STATIC "rt" "pthread" "dl")
+  endif()
+
+  if (CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL "9.0")
+    set(CMAKE_${lang}_RESPONSE_FILE_DEVICE_LINK_FLAG "--options-file ")
+    set(CMAKE_${lang}_RESPONSE_FILE_FLAG "--options-file ")
+  endif()
+
+  if (CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL "11.0")
+    set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_INCLUDES 1)
+    set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_LIBRARIES 1)
+    set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_OBJECTS 1)
+  else()
+    set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_INCLUDES 0)
+    set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_LIBRARIES 0)
+    set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_OBJECTS 0)
+  endif()
+endmacro()