diff --git a/CMakeLists.txt b/CMakeLists.txt
index b3913155b1..866390ce93 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -429,6 +429,7 @@ if(NOT CMake_TEST_EXTERNAL_CMAKE)
     execute_process(COMMAND ${CMAKE_CXX_COMPILER}
       ${CMAKE_CXX_COMPILER_ARG1} -dumpversion
       OUTPUT_VARIABLE _GXX_VERSION
+      RESULT_VARIABLE _GXX_VERSION_RESULT
     )
     string(REGEX REPLACE "([0-9])\\.([0-9])(\\.[0-9])?" "\\1\\2"
       _GXX_VERSION_SHORT ${_GXX_VERSION})
diff --git a/Modules/AndroidTestUtilities/PushToAndroidDevice.cmake b/Modules/AndroidTestUtilities/PushToAndroidDevice.cmake
index f6389d6075..234fb5fbde 100644
--- a/Modules/AndroidTestUtilities/PushToAndroidDevice.cmake
+++ b/Modules/AndroidTestUtilities/PushToAndroidDevice.cmake
@@ -41,7 +41,8 @@ function(android_push_test_files_to_device)
     set(${file_exists} "")
     execute_process(
       COMMAND ${adb_executable} shell ls ${device_file}
-      OUTPUT_VARIABLE out_var ERROR_VARIABLE out_var)
+      OUTPUT_VARIABLE out_var ERROR_VARIABLE out_var
+      RESULT_VARIABLE _result_check_file)
     if(NOT out_var) # when a directory exists but is empty the output is empty
       set(${file_exists} "YES")
     else()
diff --git a/Modules/BundleUtilities.cmake b/Modules/BundleUtilities.cmake
index 40821e011c..782e8ad55b 100644
--- a/Modules/BundleUtilities.cmake
+++ b/Modules/BundleUtilities.cmake
@@ -695,6 +695,7 @@ function(get_bundle_all_executables bundle exes_var)
       -type f \( -perm -0100 -o -perm -0010 -o -perm -0001 \)
       OUTPUT_VARIABLE file_list
       OUTPUT_STRIP_TRAILING_WHITESPACE
+      RESULT_VARIABLE _result_find
       )
     string(REPLACE "\n" ";" file_list "${file_list}")
   else()
@@ -991,7 +992,9 @@ function(link_resolved_item_into_bundle resolved_item resolved_embedded_item)
     if (NOT EXISTS "${target_dir}")
       file(MAKE_DIRECTORY "${target_dir}")
     endif()
-    execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink "${symlink_target}" "${resolved_embedded_item}")
+    execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink "${symlink_target}"
+      "${resolved_embedded_item}"
+      RESULT_VARIABLE _result_symlink)
   endif()
 endfunction()
 
@@ -1009,7 +1012,9 @@ function(copy_resolved_item_into_bundle resolved_item resolved_embedded_item)
     message(STATUS "warning: resolved_item == resolved_embedded_item - not copying...")
   else()
     #message(STATUS "copying COMMAND ${CMAKE_COMMAND} -E copy ${resolved_item} ${resolved_embedded_item}")
-    execute_process(COMMAND ${CMAKE_COMMAND} -E copy "${resolved_item}" "${resolved_embedded_item}")
+    execute_process(COMMAND ${CMAKE_COMMAND} -E copy "${resolved_item}"
+      "${resolved_embedded_item}"
+      RESULT_VARIABLE _result_copy)
     if(UNIX AND NOT APPLE)
       file(RPATH_REMOVE FILE "${resolved_embedded_item}")
     endif()
@@ -1042,14 +1047,18 @@ function(copy_resolved_framework_into_bundle resolved_item resolved_embedded_ite
     else()
       # Framework lib itself:
       #message(STATUS "copying COMMAND ${CMAKE_COMMAND} -E copy ${resolved_item} ${resolved_embedded_item}")
-      execute_process(COMMAND ${CMAKE_COMMAND} -E copy "${resolved_item}" "${resolved_embedded_item}")
+      execute_process(COMMAND ${CMAKE_COMMAND} -E copy "${resolved_item}"
+        "${resolved_embedded_item}"
+        RESULT_VARIABLE _result_copy)
 
       # Plus Resources, if they exist:
       string(REGEX REPLACE "^(.*)/[^/]+$" "\\1/Resources" resolved_resources "${resolved_item}")
       string(REGEX REPLACE "^(.*)/[^/]+$" "\\1/Resources" resolved_embedded_resources "${resolved_embedded_item}")
       if(EXISTS "${resolved_resources}")
         #message(STATUS "copying COMMAND ${CMAKE_COMMAND} -E copy_directory '${resolved_resources}' '${resolved_embedded_resources}'")
-        execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory "${resolved_resources}" "${resolved_embedded_resources}")
+        execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory
+          "${resolved_resources}" "${resolved_embedded_resources}"
+          RESULT_VARIABLE _result_copy_resources)
       endif()
 
       # Some frameworks e.g. Qt put Info.plist in wrong place, so when it is
@@ -1060,7 +1069,9 @@ function(copy_resolved_framework_into_bundle resolved_item resolved_embedded_ite
         string(REGEX REPLACE "^(.*)/[^/]+$" "\\1/Resources/Info.plist" resolved_embedded_info_plist "${resolved_embedded_item}")
         if(EXISTS "${resolved_info_plist}")
           #message(STATUS "copying COMMAND ${CMAKE_COMMAND} -E copy_directory '${resolved_info_plist}' '${resolved_embedded_info_plist}'")
-          execute_process(COMMAND ${CMAKE_COMMAND} -E copy "${resolved_info_plist}" "${resolved_embedded_info_plist}")
+          execute_process(COMMAND ${CMAKE_COMMAND} -E copy
+            "${resolved_info_plist}" "${resolved_embedded_info_plist}"
+            RESULT_VARIABLE _result_copy_info_plist)
         endif()
       endif()
 
@@ -1071,17 +1082,25 @@ function(copy_resolved_framework_into_bundle resolved_item resolved_embedded_ite
       if(resolved_embedded_versions_basename STREQUAL "Versions")
         # Ensure Current symlink points to the framework version
         if(NOT EXISTS "${resolved_embedded_versions}/Current")
-          execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink "${resolved_embedded_version}" "${resolved_embedded_versions}/Current")
+          execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink
+            "${resolved_embedded_version}"
+            "${resolved_embedded_versions}/Current"
+            RESULT_VARIABLE _result_symlink_current)
         endif()
         # Restore symlinks in framework root pointing to current framework
         # binary and resources:
         string(REGEX REPLACE "^(.*)/[^/]+/[^/]+/[^/]+$" "\\1" resolved_embedded_root "${resolved_embedded_item}")
         string(REGEX REPLACE "^.*/([^/]+)$" "\\1" resolved_embedded_item_basename "${resolved_embedded_item}")
         if(NOT EXISTS "${resolved_embedded_root}/${resolved_embedded_item_basename}")
-          execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink "Versions/Current/${resolved_embedded_item_basename}" "${resolved_embedded_root}/${resolved_embedded_item_basename}")
+          execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink
+            "Versions/Current/${resolved_embedded_item_basename}"
+            "${resolved_embedded_root}/${resolved_embedded_item_basename}"
+            RESULT_VARIABLE _result_symlink_item)
         endif()
         if(NOT EXISTS "${resolved_embedded_root}/Resources")
-          execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink "Versions/Current/Resources" "${resolved_embedded_root}/Resources")
+          execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink
+            "Versions/Current/Resources" "${resolved_embedded_root}/Resources"
+            RESULT_VARIABLE _result_symlink_resources)
         endif()
       endif()
     endif()
@@ -1156,6 +1175,7 @@ function(fixup_bundle_item resolved_embedded_item exepath dirs)
   execute_process(COMMAND ${CMAKE_INSTALL_NAME_TOOL}
     OUTPUT_VARIABLE install_name_tool_usage
     ERROR_VARIABLE  install_name_tool_usage
+    RESULT_VARIABLE _result_install_name_tool_usage
     )
   if(install_name_tool_usage MATCHES ".*-delete_rpath.*")
     foreach(rpath ${${ikey}_RPATHS})
@@ -1177,7 +1197,8 @@ function(fixup_bundle_item resolved_embedded_item exepath dirs)
        NOT file_contents MATCHES "^#!")
       set(cmd ${CMAKE_INSTALL_NAME_TOOL} ${changes} "${resolved_embedded_item}")
       if(BU_CHMOD_BUNDLE_ITEMS)
-        execute_process(COMMAND chmod u+w "${resolved_embedded_item}")
+        execute_process(COMMAND chmod u+w "${resolved_embedded_item}"
+          RESULT_VARIABLE _result_chmod)
       endif()
       execute_process(COMMAND ${cmd} RESULT_VARIABLE install_name_tool_result)
       if(NOT install_name_tool_result EQUAL 0)
@@ -1278,7 +1299,8 @@ endfunction()
 
 
 function(copy_and_fixup_bundle src dst libs dirs)
-  execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory "${src}" "${dst}")
+  execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory "${src}" "${dst}"
+    RESULT_VARIABLE _result_copy_directory)
   fixup_bundle("${dst}" "${libs}" "${dirs}")
 endfunction()
 
diff --git a/Modules/CMakeAddFortranSubdirectory.cmake b/Modules/CMakeAddFortranSubdirectory.cmake
index 7eec1f2ecb..3b45f171fa 100644
--- a/Modules/CMakeAddFortranSubdirectory.cmake
+++ b/Modules/CMakeAddFortranSubdirectory.cmake
@@ -154,7 +154,8 @@ function(_setup_mingw_config_and_build source_dir build_dir)
     set(_mingw_target "Target:.*mingw32")
   endif()
   execute_process(COMMAND "${MINGW_GFORTRAN}" -v
-    ERROR_VARIABLE out ERROR_STRIP_TRAILING_WHITESPACE)
+    ERROR_VARIABLE out ERROR_STRIP_TRAILING_WHITESPACE
+    RESULT_VARIABLE _result_mingw_gfortran_v)
   if(NOT "${out}" MATCHES "${_mingw_target}")
     string(REPLACE "\n" "\n  " out "  ${out}")
     message(FATAL_ERROR
diff --git a/Modules/CMakeDetermineCSharpCompiler.cmake b/Modules/CMakeDetermineCSharpCompiler.cmake
index 0528252d03..7512e6907b 100644
--- a/Modules/CMakeDetermineCSharpCompiler.cmake
+++ b/Modules/CMakeDetermineCSharpCompiler.cmake
@@ -22,7 +22,10 @@ if(NOT CMAKE_CSharp_COMPILER_ID_RUN)
   include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerId.cmake)
   CMAKE_DETERMINE_COMPILER_ID(CSharp CSFLAGS CMakeCSharpCompilerId.cs)
 
-  execute_process(COMMAND "${CMAKE_CSharp_COMPILER}" "/help /preferreduilang:en-US" OUTPUT_VARIABLE output)
+  execute_process(COMMAND "${CMAKE_CSharp_COMPILER}"
+    "/help /preferreduilang:en-US"
+    OUTPUT_VARIABLE output
+    RESULT_VARIABLE _result_csharp_help)
   string(REPLACE "\n" ";" output "${output}")
   foreach(line ${output})
     string(TOUPPER ${line} line)
diff --git a/Modules/CMakeDetermineSwiftCompiler.cmake b/Modules/CMakeDetermineSwiftCompiler.cmake
index e9285b624c..d1c09fc814 100644
--- a/Modules/CMakeDetermineSwiftCompiler.cmake
+++ b/Modules/CMakeDetermineSwiftCompiler.cmake
@@ -99,7 +99,8 @@ elseif(NOT DEFINED CMAKE_Swift_COMPILER_USE_OLD_DRIVER)
   # Execute in dry-run mode so no compilation will be actually performed.
   execute_process(COMMAND ${_CMAKE_Swift_COMPILER_CHECK_COMMAND}
     WORKING_DIRECTORY "${CMAKE_Swift_COMPILER_DRIVER_TEST_DIR}"
-    OUTPUT_VARIABLE _CMAKE_Swift_COMPILER_CHECK_OUTPUT)
+    OUTPUT_VARIABLE _CMAKE_Swift_COMPILER_CHECK_OUTPUT
+    RESULT_VARIABLE _result_CMAKE_Swift_COMPILER)
 
   # Check the first frontend execution.  It is on the first line of output.
   # The old driver treats all inputs as Swift sources while the new driver
@@ -133,7 +134,8 @@ if(CMAKE_Swift_COMPILER_VERSION VERSION_GREATER_EQUAL 5.2)
   endif()
   execute_process(
     COMMAND ${target_info_command}
-    OUTPUT_VARIABLE swift_target_info)
+    OUTPUT_VARIABLE swift_target_info
+    RESULT_VARIABLE _result_swift_target_info)
   message(CONFIGURE_LOG "Swift target info:\n" "${swift_target_info}")
   string(JSON module_triple GET "${swift_target_info}" "target" "moduleTriple")
   set(CMAKE_Swift_MODULE_TRIPLE ${module_triple})
diff --git a/Modules/CMakeDetermineVSServicePack.cmake b/Modules/CMakeDetermineVSServicePack.cmake
index c9a9fb988b..4f148743ae 100644
--- a/Modules/CMakeDetermineVSServicePack.cmake
+++ b/Modules/CMakeDetermineVSServicePack.cmake
@@ -121,6 +121,7 @@ function(_DetermineVSServicePack_FastCheckVersionWithCompiler _SUCCESS_VAR  _VER
           COMMAND ${CMAKE_CXX_COMPILER} -?
           ERROR_VARIABLE _output
           OUTPUT_QUIET
+          RESULT_VARIABLE _result_cl_help
         )
 
       if(_output MATCHES "Compiler Version (([0-9]+)\\.([0-9]+)\\.([0-9]+)(\\.([0-9]+))?)")
diff --git a/Modules/CMakeExtraGeneratorDetermineCompilerMacrosAndIncludeDirs.cmake b/Modules/CMakeExtraGeneratorDetermineCompilerMacrosAndIncludeDirs.cmake
index 0b21e36fa8..b1e65c9966 100644
--- a/Modules/CMakeExtraGeneratorDetermineCompilerMacrosAndIncludeDirs.cmake
+++ b/Modules/CMakeExtraGeneratorDetermineCompilerMacrosAndIncludeDirs.cmake
@@ -31,7 +31,8 @@ macro(_DETERMINE_GCC_SYSTEM_INCLUDE_DIRS _lang _resultIncludeDirs _resultDefines
   execute_process(COMMAND ${_compilerExecutable} ${_arg1} ${_stdver} ${_stdlib} -v -E -x ${_lang} -dD dummy
                   WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/CMakeFiles
                   ERROR_VARIABLE _gccOutput
-                  OUTPUT_VARIABLE _gccStdout )
+                  OUTPUT_VARIABLE _gccStdout
+                  RESULT_VARIABLE _result_gcc)
   file(REMOVE "${CMAKE_BINARY_DIR}/CMakeFiles/dummy")
 
   # First find the system include dirs:
diff --git a/Modules/CMakeFindJavaCommon.cmake b/Modules/CMakeFindJavaCommon.cmake
index 95ca9b57b6..f3e34936b4 100644
--- a/Modules/CMakeFindJavaCommon.cmake
+++ b/Modules/CMakeFindJavaCommon.cmake
@@ -22,6 +22,7 @@ else()
         OUTPUT_VARIABLE _CMD_JAVA_HOME
         OUTPUT_STRIP_TRAILING_WHITESPACE
         ERROR_QUIET
+        RESULT_VARIABLE _result_java_home
       )
     endif()
     if(_CMD_JAVA_HOME AND IS_DIRECTORY "${_CMD_JAVA_HOME}")
diff --git a/Modules/CMakeFindPackageMode.cmake b/Modules/CMakeFindPackageMode.cmake
index 6e2762cf41..62e33e047f 100644
--- a/Modules/CMakeFindPackageMode.cmake
+++ b/Modules/CMakeFindPackageMode.cmake
@@ -71,7 +71,9 @@ if(UNIX)
       find_program(FILE_EXECUTABLE file)
       if(FILE_EXECUTABLE)
         get_filename_component(FILE_ABSPATH "${FILE_EXECUTABLE}" ABSOLUTE)
-        execute_process(COMMAND "${FILE_ABSPATH}" "${FILE_ABSPATH}" OUTPUT_VARIABLE fileOutput ERROR_QUIET)
+        execute_process(COMMAND "${FILE_ABSPATH}" "${FILE_ABSPATH}"
+          OUTPUT_VARIABLE fileOutput ERROR_QUIET
+          RESULT_VARIABLE _result_file)
         if("${fileOutput}" MATCHES "64-bit")
           set(CMAKE_SIZEOF_VOID_P 8)
         endif()
diff --git a/Modules/CTestCoverageCollectGCOV.cmake b/Modules/CTestCoverageCollectGCOV.cmake
index f36c0222d8..acde687693 100644
--- a/Modules/CTestCoverageCollectGCOV.cmake
+++ b/Modules/CTestCoverageCollectGCOV.cmake
@@ -419,7 +419,9 @@ ${uncovered_files_for_tar}
     "--mtime=1970-01-01 0:0:0 UTC"
     "--format=gnutar"
     --files-from=${coverage_dir}/coverage_file_list.txt
-    WORKING_DIRECTORY ${binary_dir})
+    WORKING_DIRECTORY ${binary_dir}
+    RESULT_VARIABLE _result_tar
+    )
 
   if (GCOV_DELETE)
     foreach(gcov_file ${unfiltered_gcov_files})
diff --git a/Modules/ExternalProject/shared_internal_commands.cmake b/Modules/ExternalProject/shared_internal_commands.cmake
index 64ad3e3ddc..71d95c4716 100644
--- a/Modules/ExternalProject/shared_internal_commands.cmake
+++ b/Modules/ExternalProject/shared_internal_commands.cmake
@@ -13,6 +13,7 @@ function(_ep_get_git_remote_url output_variable working_directory)
     OUTPUT_VARIABLE git_symbolic_ref
     OUTPUT_STRIP_TRAILING_WHITESPACE
     ERROR_QUIET
+    RESULT_VARIABLE _result_git_symbolic_ref
   )
 
   if(NOT git_symbolic_ref STREQUAL "")
@@ -24,6 +25,7 @@ function(_ep_get_git_remote_url output_variable working_directory)
       OUTPUT_VARIABLE git_remote_name
       OUTPUT_STRIP_TRAILING_WHITESPACE
       ERROR_QUIET
+      RESULT_VARIABLE _result_git_branch_remote
     )
   endif()
 
@@ -36,6 +38,7 @@ function(_ep_get_git_remote_url output_variable working_directory)
       OUTPUT_VARIABLE git_remote_list
       OUTPUT_STRIP_TRAILING_WHITESPACE
       ERROR_QUIET
+      RESULT_VARIABLE _result_git_remote_list
     )
     string(REPLACE "\n" ";" git_remote_list "${git_remote_list}")
     list(LENGTH git_remote_list git_remote_list_length)
@@ -70,6 +73,7 @@ function(_ep_get_git_remote_url output_variable working_directory)
     OUTPUT_STRIP_TRAILING_WHITESPACE
     COMMAND_ERROR_IS_FATAL LAST
     ENCODING UTF-8   # Needed to handle non-ascii characters in local paths
+    RESULT_VARIABLE _result_git_remote_url
   )
 
   set("${output_variable}" "${git_remote_url}" PARENT_SCOPE)
diff --git a/Modules/FindCUDAToolkit.cmake b/Modules/FindCUDAToolkit.cmake
index 73e30d2741..98ac302b9e 100644
--- a/Modules/FindCUDAToolkit.cmake
+++ b/Modules/FindCUDAToolkit.cmake
@@ -1022,7 +1022,9 @@ else()
     endif()
   elseif(CUDAToolkit_NVCC_EXECUTABLE)
     # Compute the version by invoking nvcc
-    execute_process(COMMAND ${CUDAToolkit_NVCC_EXECUTABLE} "--version" OUTPUT_VARIABLE NVCC_OUT)
+    execute_process(COMMAND ${CUDAToolkit_NVCC_EXECUTABLE} "--version"
+      OUTPUT_VARIABLE NVCC_OUT
+      RESULT_VARIABLE _nvcc_version_result)
     if(NVCC_OUT MATCHES [=[ V([0-9]+)\.([0-9]+)\.([0-9]+)]=])
       set(CUDAToolkit_VERSION_MAJOR "${CMAKE_MATCH_1}")
       set(CUDAToolkit_VERSION_MINOR "${CMAKE_MATCH_2}")
diff --git a/Modules/FindCURL.cmake b/Modules/FindCURL.cmake
index 9af420fcd7..d5ca65ecd4 100644
--- a/Modules/FindCURL.cmake
+++ b/Modules/FindCURL.cmake
@@ -257,16 +257,19 @@ if(CURL_FIND_COMPONENTS)
       execute_process(COMMAND ${CURL_CONFIG_EXECUTABLE} --version
                       OUTPUT_VARIABLE CURL_CONFIG_VERSION_STRING
                       ERROR_QUIET
-                      OUTPUT_STRIP_TRAILING_WHITESPACE)
+                      OUTPUT_STRIP_TRAILING_WHITESPACE
+                      RESULT_VARIABLE _curl_config_version_result)
       execute_process(COMMAND ${CURL_CONFIG_EXECUTABLE} --feature
                       OUTPUT_VARIABLE CURL_CONFIG_FEATURES_STRING
                       ERROR_QUIET
-                      OUTPUT_STRIP_TRAILING_WHITESPACE)
+                      OUTPUT_STRIP_TRAILING_WHITESPACE
+                      RESULT_VARIABLE _curl_config_features_result)
       string(REPLACE "\n" ";" CURL_SUPPORTED_FEATURES "${CURL_CONFIG_FEATURES_STRING}")
       execute_process(COMMAND ${CURL_CONFIG_EXECUTABLE} --protocols
                       OUTPUT_VARIABLE CURL_CONFIG_PROTOCOLS_STRING
                       ERROR_QUIET
-                      OUTPUT_STRIP_TRAILING_WHITESPACE)
+                      OUTPUT_STRIP_TRAILING_WHITESPACE
+                      RESULT_VARIABLE _curl_config_protocols_result)
       string(REPLACE "\n" ";" CURL_SUPPORTED_PROTOCOLS "${CURL_CONFIG_PROTOCOLS_STRING}")
     endif()
   endif()
diff --git a/Modules/FindEnvModules.cmake b/Modules/FindEnvModules.cmake
index bb19d045da..40f0875924 100644
--- a/Modules/FindEnvModules.cmake
+++ b/Modules/FindEnvModules.cmake
@@ -229,6 +229,7 @@ function(env_module)
   execute_process(
     COMMAND mktemp -t module.cmake.XXXXXXXXXXXX
     OUTPUT_VARIABLE tempfile_name
+    RESULT_VARIABLE _tempfile_result
   )
   string(STRIP "${tempfile_name}" tempfile_name)
 
diff --git a/Modules/FindFLTK.cmake b/Modules/FindFLTK.cmake
index eed585cf07..9b4605f369 100644
--- a/Modules/FindFLTK.cmake
+++ b/Modules/FindFLTK.cmake
@@ -289,7 +289,9 @@ else()
     find_program(FLTK_CONFIG_SCRIPT fltk-config PATHS ${FLTK_BIN_DIR})
     if(FLTK_CONFIG_SCRIPT)
       if(NOT FLTK_INCLUDE_DIR)
-        execute_process(COMMAND ${FLTK_CONFIG_SCRIPT} --cxxflags OUTPUT_VARIABLE FLTK_CXXFLAGS)
+        execute_process(COMMAND ${FLTK_CONFIG_SCRIPT} --cxxflags
+          OUTPUT_VARIABLE FLTK_CXXFLAGS
+          RESULT_VARIABLE _fltk_cxxflags_result)
         if(FLTK_CXXFLAGS)
           string(REGEX MATCHALL "-I[^ ]*" _fltk_temp_dirs ${FLTK_CXXFLAGS})
           string(REPLACE "-I" "" _fltk_temp_dirs "${_fltk_temp_dirs}")
@@ -313,7 +315,9 @@ else()
   # Try to find FLTK library
   if(UNIX)
     if(FLTK_CONFIG_SCRIPT)
-      execute_process(COMMAND ${FLTK_CONFIG_SCRIPT} --libs OUTPUT_VARIABLE _FLTK_POSSIBLE_LIBS)
+      execute_process(COMMAND ${FLTK_CONFIG_SCRIPT} --libs
+        OUTPUT_VARIABLE _FLTK_POSSIBLE_LIBS
+        RESULT_VARIABLE _fltk_config_libs_result)
       if(_FLTK_POSSIBLE_LIBS)
         get_filename_component(_FLTK_POSSIBLE_LIBRARY_DIR ${_FLTK_POSSIBLE_LIBS} PATH)
       endif()
@@ -350,7 +354,8 @@ else()
   if(UNIX)
     if(FLTK_CONFIG_SCRIPT)
       execute_process(COMMAND ${FLTK_CONFIG_SCRIPT} --use-images --ldflags
-        OUTPUT_VARIABLE FLTK_IMAGES_LDFLAGS)
+        OUTPUT_VARIABLE FLTK_IMAGES_LDFLAGS
+        RESULT_VARIABLE _fltk_images_ldflags_result)
       set(FLTK_LIBS_EXTRACT_REGEX ".*-lfltk_images (.*) -lfltk.*")
       if("${FLTK_IMAGES_LDFLAGS}" MATCHES "${FLTK_LIBS_EXTRACT_REGEX}")
         string(REGEX REPLACE " +" ";" FLTK_IMAGES_LIBS "${CMAKE_MATCH_1}")
diff --git a/Modules/FindGSL.cmake b/Modules/FindGSL.cmake
index 041e9d1403..0d30ffb7e8 100644
--- a/Modules/FindGSL.cmake
+++ b/Modules/FindGSL.cmake
@@ -171,7 +171,8 @@ if( NOT GSL_VERSION )
     execute_process(
       COMMAND "${GSL_CONFIG_EXECUTABLE}" --version
       OUTPUT_VARIABLE GSL_VERSION
-      OUTPUT_STRIP_TRAILING_WHITESPACE )
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      RESULT_VARIABLE _gsl_config_version_result)
   endif()
 
   # 2. If gsl-config is not available, try looking in gsl/gsl_version.h
diff --git a/Modules/FindGettext.cmake b/Modules/FindGettext.cmake
index 347d30d057..13305807a8 100644
--- a/Modules/FindGettext.cmake
+++ b/Modules/FindGettext.cmake
@@ -413,7 +413,8 @@ if(GETTEXT_MSGMERGE_EXECUTABLE)
   execute_process(COMMAND ${GETTEXT_MSGMERGE_EXECUTABLE} --version
                   OUTPUT_VARIABLE gettext_version
                   ERROR_QUIET
-                  OUTPUT_STRIP_TRAILING_WHITESPACE)
+                  OUTPUT_STRIP_TRAILING_WHITESPACE
+                  RESULT_VARIABLE _gettext_msgmerge_version_result)
   get_filename_component(msgmerge_name ${GETTEXT_MSGMERGE_EXECUTABLE} NAME)
   get_filename_component(msgmerge_namewe ${GETTEXT_MSGMERGE_EXECUTABLE} NAME_WE)
   if(gettext_version MATCHES "^(${msgmerge_name}|${msgmerge_namewe}) \\([^\\)]*\\) ([0-9\\.]+[^ \n]*)")
diff --git a/Modules/FindGnuplot.cmake b/Modules/FindGnuplot.cmake
index f5bf309f0d..5a227356c4 100644
--- a/Modules/FindGnuplot.cmake
+++ b/Modules/FindGnuplot.cmake
@@ -87,7 +87,8 @@ if (GNUPLOT_EXECUTABLE)
     execute_process(COMMAND "${GNUPLOT_EXECUTABLE}" --version
                   OUTPUT_VARIABLE GNUPLOT_OUTPUT_VARIABLE
                   ERROR_QUIET
-                  OUTPUT_STRIP_TRAILING_WHITESPACE)
+                  OUTPUT_STRIP_TRAILING_WHITESPACE
+                  RESULT_VARIABLE _gnuplot_version_result)
 
     string(REGEX REPLACE "^gnuplot ([0-9\\.]+)( patchlevel )?" "\\1." Gnuplot_VERSION "${GNUPLOT_OUTPUT_VARIABLE}")
     string(REGEX REPLACE "\\.$" "" Gnuplot_VERSION "${Gnuplot_VERSION}")
diff --git a/Modules/FindIce.cmake b/Modules/FindIce.cmake
index a0be791926..f672ba86ee 100644
--- a/Modules/FindIce.cmake
+++ b/Modules/FindIce.cmake
@@ -662,7 +662,8 @@ function(_Ice_FIND)
 
     execute_process(COMMAND ${Ice_SLICE2CPP_EXECUTABLE} --version
       ERROR_VARIABLE Ice_VERSION_SLICE2CPP_FULL
-      ERROR_STRIP_TRAILING_WHITESPACE)
+      ERROR_STRIP_TRAILING_WHITESPACE
+      RESULT_VARIABLE _slice2cpp_version_result)
 
     # restore the previous LC_ALL
     set(ENV{LC_ALL} ${_Ice_SAVED_LC_ALL})
diff --git a/Modules/FindIcotool.cmake b/Modules/FindIcotool.cmake
index ea9cb043ae..b4eeb7edbd 100644
--- a/Modules/FindIcotool.cmake
+++ b/Modules/FindIcotool.cmake
@@ -81,6 +81,7 @@ if(ICOTOOL_EXECUTABLE)
     OUTPUT_VARIABLE Icotool_VERSION
     ERROR_QUIET
     OUTPUT_STRIP_TRAILING_WHITESPACE
+    RESULT_VARIABLE _icotool_version_result
   )
   if("${Icotool_VERSION}" MATCHES "^icotool \\([^\\)]*\\) ([0-9\\.]+[^ \n]*)")
     set(Icotool_VERSION "${CMAKE_MATCH_1}")
diff --git a/Modules/FindImageMagick.cmake b/Modules/FindImageMagick.cmake
index c34ebdb22d..d1b482ccd8 100644
--- a/Modules/FindImageMagick.cmake
+++ b/Modules/FindImageMagick.cmake
@@ -285,6 +285,7 @@ function(_ImageMagick_GetVersion)
       OUTPUT_VARIABLE version
       ERROR_QUIET
       OUTPUT_STRIP_TRAILING_WHITESPACE
+      RESULT_VARIABLE _version_result
     )
 
     if(version MATCHES "^Version: ImageMagick ([-0-9.]+)")
diff --git a/Modules/FindMatlab.cmake b/Modules/FindMatlab.cmake
index 5e3b3658d1..5f7c83bc51 100644
--- a/Modules/FindMatlab.cmake
+++ b/Modules/FindMatlab.cmake
@@ -1083,6 +1083,7 @@ function(matlab_get_mex_suffix matlab_root mex_suffix)
     OUTPUT_VARIABLE _matlab_mex_extension
     ERROR_VARIABLE _matlab_mex_extension_error
     OUTPUT_STRIP_TRAILING_WHITESPACE
+    RESULT_VARIABLE _matlab_mex_extension_result
     ${devnull})
 
   if(_matlab_mex_extension_error)
diff --git a/Modules/FindODBC.cmake b/Modules/FindODBC.cmake
index 69c6ddb017..a668072d18 100644
--- a/Modules/FindODBC.cmake
+++ b/Modules/FindODBC.cmake
@@ -163,9 +163,11 @@ endif()
 if (UNIX AND ODBC_CONFIG)
   # unixODBC and iODBC accept unified command line options
   execute_process(COMMAND ${ODBC_CONFIG} --cflags
-    OUTPUT_VARIABLE _cflags OUTPUT_STRIP_TRAILING_WHITESPACE)
+    OUTPUT_VARIABLE _cflags OUTPUT_STRIP_TRAILING_WHITESPACE
+    RESULT_VARIABLE _odbc_config_cflags_result)
   execute_process(COMMAND ${ODBC_CONFIG} --libs
-    OUTPUT_VARIABLE _libs OUTPUT_STRIP_TRAILING_WHITESPACE)
+    OUTPUT_VARIABLE _libs OUTPUT_STRIP_TRAILING_WHITESPACE
+    RESULT_VARIABLE _odbc_config_libs_result)
 
   # Collect paths of include directories from CFLAGS
   separate_arguments(_cflags NATIVE_COMMAND "${_cflags}")
diff --git a/Modules/FindOpenMP.cmake b/Modules/FindOpenMP.cmake
index 6ef1152a69..55f2de72f3 100644
--- a/Modules/FindOpenMP.cmake
+++ b/Modules/FindOpenMP.cmake
@@ -365,7 +365,8 @@ function(_OPENMP_GET_FLAGS LANG FLAG_MODE OPENMP_FLAG_VAR OPENMP_LIB_NAMES_VAR)
             COMMAND ${CMAKE_${LANG}_COMPILER} -print-search-dirs
             OUTPUT_VARIABLE output_lines
             COMMAND_ERROR_IS_FATAL ANY
-            ERROR_QUIET)
+            ERROR_QUIET
+            RESULT_VARIABLE _result_lcc_output)
           if("${output_lines}" MATCHES ".*\nlibraries:[ \t]+(.*:)\n.*")
             string(REPLACE ":" ";" implicit_dirs_addon "${CMAKE_MATCH_1}")
             list(PREPEND OpenMP_${LANG}_IMPLICIT_LINK_DIRS ${implicit_dirs_addon})
diff --git a/Modules/FindProtobuf.cmake b/Modules/FindProtobuf.cmake
index 62baba1deb..cec56ac3fe 100644
--- a/Modules/FindProtobuf.cmake
+++ b/Modules/FindProtobuf.cmake
@@ -992,7 +992,8 @@ if(Protobuf_INCLUDE_DIR)
   if(Protobuf_PROTOC_EXECUTABLE)
     # Check Protobuf compiler version to be aligned with libraries version
     execute_process(COMMAND ${Protobuf_PROTOC_EXECUTABLE} --version
-                    OUTPUT_VARIABLE _PROTOBUF_PROTOC_EXECUTABLE_VERSION)
+                    OUTPUT_VARIABLE _PROTOBUF_PROTOC_EXECUTABLE_VERSION
+                    RESULT_VARIABLE _PROTOBUF_PROTOC_EXECUTABLE_VERSION_RESULT)
 
     if("${_PROTOBUF_PROTOC_EXECUTABLE_VERSION}" MATCHES "libprotoc ([0-9.]+)")
       set(_PROTOBUF_PROTOC_EXECUTABLE_VERSION "${CMAKE_MATCH_1}")
diff --git a/Modules/FindPythonLibs.cmake b/Modules/FindPythonLibs.cmake
index 272b176098..f8e9705b61 100644
--- a/Modules/FindPythonLibs.cmake
+++ b/Modules/FindPythonLibs.cmake
@@ -483,7 +483,10 @@ extern \"C\" {
   file(APPEND ${_filenameTmp} "#ifndef EXCLUDE_LOAD_ALL_FUNCTION\nvoid CMakeLoadAllPythonModules(void)\n{\n  ${_name}_LoadAllPythonModules();\n}\n#endif\n\n#endif\n")
 
 # with configure_file() cmake complains that you may not use a file created using file(WRITE) as input file for configure_file()
-  execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different "${_filenameTmp}" "${_filename}" OUTPUT_QUIET ERROR_QUIET)
+  execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
+    "${_filenameTmp}" "${_filename}"
+    OUTPUT_QUIET ERROR_QUIET
+    RESULT_VARIABLE _result_copy)
 
 endfunction()
 
diff --git a/Modules/FindSquish.cmake b/Modules/FindSquish.cmake
index f405e45a26..9622499d32 100644
--- a/Modules/FindSquish.cmake
+++ b/Modules/FindSquish.cmake
@@ -299,7 +299,8 @@ if(SQUISH_CLIENT_EXECUTABLE)
   set(SQUISH_CLIENT_EXECUTABLE_FOUND 1)
   execute_process(COMMAND "${SQUISH_CLIENT_EXECUTABLE}" --version
                   OUTPUT_VARIABLE _squishVersionOutput
-                  ERROR_QUIET )
+                  ERROR_QUIET
+                  RESULT_VARIABLE _squishVersionResult)
   if("${_squishVersionOutput}" MATCHES "([0-9]+)\\.([0-9]+)\\.([0-9]+)")
     set(SQUISH_VERSION_MAJOR "${CMAKE_MATCH_1}")
     set(SQUISH_VERSION_MINOR "${CMAKE_MATCH_2}")
diff --git a/Modules/FindTclsh.cmake b/Modules/FindTclsh.cmake
index 81a2cbf168..f57b8b2bf2 100644
--- a/Modules/FindTclsh.cmake
+++ b/Modules/FindTclsh.cmake
@@ -139,7 +139,8 @@ if(TCL_TCLSH)
                   COMMAND "${TCL_TCLSH}"
                   OUTPUT_VARIABLE Tclsh_VERSION
                   ERROR_QUIET
-                  OUTPUT_STRIP_TRAILING_WHITESPACE)
+                  OUTPUT_STRIP_TRAILING_WHITESPACE
+                  RESULT_VARIABLE _tclsh_version_result)
   set(TCLSH_VERSION_STRING "${Tclsh_VERSION}")
 endif()
 
diff --git a/Modules/FindXCTest.cmake b/Modules/FindXCTest.cmake
index 7b4cc415e7..4ffcf8aa8f 100644
--- a/Modules/FindXCTest.cmake
+++ b/Modules/FindXCTest.cmake
@@ -150,7 +150,8 @@ unset(_PRESERVED_CMAKE_FIND_ROOT_PATH)
 execute_process(
   COMMAND xcrun --find xctest
   OUTPUT_VARIABLE _xcrun_out OUTPUT_STRIP_TRAILING_WHITESPACE
-  ERROR_VARIABLE _xcrun_err)
+  ERROR_VARIABLE _xcrun_err
+  RESULT_VARIABLE _xcrun_result)
 if(_xcrun_out)
   set(XCTest_EXECUTABLE "${_xcrun_out}" CACHE FILEPATH "XCTest executable")
   mark_as_advanced(XCTest_EXECUTABLE)
diff --git a/Modules/FindwxWindows.cmake b/Modules/FindwxWindows.cmake
index 90cb0b7a05..f869cced89 100644
--- a/Modules/FindwxWindows.cmake
+++ b/Modules/FindwxWindows.cmake
@@ -708,7 +708,8 @@ else()
       # rpath:
       execute_process(COMMAND ${CMAKE_WXWINDOWS_WXCONFIG_EXECUTABLE}
         ${WX_CONFIG_ARGS_LIBS}
-        OUTPUT_VARIABLE WX_CONFIG_LIBS )
+        OUTPUT_VARIABLE WX_CONFIG_LIBS
+        RESULT_VARIABLE _wx_config_libs_result)
 
       ## extract linkdirs (-L) for rpath
       ## use regular expression to match wildcard equivalent "-L*<endchar>"
diff --git a/Modules/Internal/CMakeCUDAFindToolkit.cmake b/Modules/Internal/CMakeCUDAFindToolkit.cmake
index 8fd408994f..ff67ef0755 100644
--- a/Modules/Internal/CMakeCUDAFindToolkit.cmake
+++ b/Modules/Internal/CMakeCUDAFindToolkit.cmake
@@ -110,7 +110,8 @@ macro(cmake_cuda_find_toolkit lang lang_var_)
   # each of which has a different layout, we need to extract the CUDA toolkit root from the compiler
   # itself, allowing us to support numerous different scattered toolkit layouts
   execute_process(COMMAND ${_CUDA_NVCC_EXECUTABLE} "-v" "__cmake_determine_cuda"
-    OUTPUT_VARIABLE _CUDA_NVCC_OUT ERROR_VARIABLE _CUDA_NVCC_OUT)
+    OUTPUT_VARIABLE _CUDA_NVCC_OUT ERROR_VARIABLE _CUDA_NVCC_OUT
+    RESULT_VARIABLE _result_nvcc_out)
   if(_CUDA_NVCC_OUT MATCHES "\\#\\$ TOP=([^\r\n]*)")
     get_filename_component(${lang_var_}TOOLKIT_ROOT "${CMAKE_MATCH_1}" ABSOLUTE)
   else()
@@ -161,7 +162,9 @@ macro(cmake_cuda_find_toolkit lang lang_var_)
   # For regular nvcc we the toolkit version is the same as the compiler version and we can parse it from the vendor test output.
   # For Clang we need to invoke nvcc to get version output.
   if(CMAKE_${lang}_COMPILER_ID STREQUAL "Clang")
-    execute_process(COMMAND ${_CUDA_NVCC_EXECUTABLE} "--version" OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT)
+    execute_process(COMMAND ${_CUDA_NVCC_EXECUTABLE} "--version"
+      OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
+      RESULT_VARIABLE _result_nvcc_version)
   endif()
 
   if(CMAKE_${lang}_COMPILER_ID_OUTPUT MATCHES [=[V([0-9]+\.[0-9]+\.[0-9]+)]=])
diff --git a/Modules/Internal/CMakeChipStarHIP.cmake b/Modules/Internal/CMakeChipStarHIP.cmake
index 1249220ca4..4e03b7693b 100644
--- a/Modules/Internal/CMakeChipStarHIP.cmake
+++ b/Modules/Internal/CMakeChipStarHIP.cmake
@@ -42,7 +42,8 @@ function(_cmake_chipstar_set_compiler_id_flags)
   set(_hip_path "$ENV{HIP_PATH}")
   if(NOT IS_DIRECTORY "${_hip_path}")
     execute_process(COMMAND hipconfig --rocmpath
-      OUTPUT_VARIABLE _hip_path OUTPUT_STRIP_TRAILING_WHITESPACE)
+      OUTPUT_VARIABLE _hip_path OUTPUT_STRIP_TRAILING_WHITESPACE
+      RESULT_VARIABLE _result_hipconfig)
   endif()
   if(IS_DIRECTORY "${_hip_path}")
     file(TO_CMAKE_PATH "${_hip_path}" _hip_path)
diff --git a/Modules/Internal/CPack/CPackDeb.cmake b/Modules/Internal/CPack/CPackDeb.cmake
index 1ebcaaa2d3..c4d7155b10 100644
--- a/Modules/Internal/CPack/CPackDeb.cmake
+++ b/Modules/Internal/CPack/CPackDeb.cmake
@@ -382,6 +382,7 @@ function(cpack_deb_prepare_package_vars)
         OUTPUT_VARIABLE _TMP_VERSION
         ERROR_QUIET
         OUTPUT_STRIP_TRAILING_WHITESPACE
+        RESULT_VARIABLE _result_shlibdeps_version
       )
       if(_TMP_VERSION MATCHES "dpkg-shlibdeps version ([0-9]+\\.[0-9]+\\.[0-9]+)")
         set(SHLIBDEPS_EXECUTABLE_VERSION "${CMAKE_MATCH_1}")
@@ -413,6 +414,7 @@ function(cpack_deb_prepare_package_vars)
           OUTPUT_VARIABLE _TMP_HELP
           ERROR_QUIET
           OUTPUT_STRIP_TRAILING_WHITESPACE
+          RESULT_VARIABLE _result_shlibdeps_help
         )
         if(_TMP_HELP MATCHES "--ignore-missing-info")
           set(IGNORE_MISSING_INFO_FLAG "--ignore-missing-info")
@@ -621,6 +623,7 @@ function(cpack_deb_prepare_package_vars)
       COMMAND "${DPKG_EXECUTABLE}" --print-architecture
       OUTPUT_VARIABLE CPACK_DEBIAN_PACKAGE_ARCHITECTURE
       OUTPUT_STRIP_TRAILING_WHITESPACE
+      RESULT_VARIABLE _result_dpkg_arch
     )
   endif()
 
@@ -878,6 +881,7 @@ function(cpack_deb_prepare_package_vars)
         COMMAND "${DPKG_EXECUTABLE}" --version
         OUTPUT_VARIABLE DPKG_VERSION
         OUTPUT_STRIP_TRAILING_WHITESPACE
+        RESULT_VARIABLE _result_dpkg_version
       )
       set(_dpkg_version_re "Debian 'dpkg' package management program version ([0-9]+\.[0-9]+\.[0-9]+).*")
       if(DPKG_VERSION MATCHES "${_dpkg_version_re}")
diff --git a/Modules/Internal/CPack/CPackRPM.cmake b/Modules/Internal/CPack/CPackRPM.cmake
index 75b3b40fae..84665506d9 100644
--- a/Modules/Internal/CPack/CPackRPM.cmake
+++ b/Modules/Internal/CPack/CPackRPM.cmake
@@ -67,6 +67,7 @@ function(get_file_permissions FILE RETURN_VAR)
       OUTPUT_VARIABLE permissions_str
       ERROR_QUIET
       OUTPUT_STRIP_TRAILING_WHITESPACE
+      RESULT_VARIABLE _result_stat_permissions
     )
 
   string(REGEX REPLACE "(.)" "\\1;" permissions "${permissions_str}")
@@ -581,7 +582,9 @@ function(cpack_rpm_prepare_install_files INSTALL_FILES_LIST WDIR PACKAGE_PREFIXE
                   BASE_DIRECTORY "${SYMLINK_LOCATION_}"
                   OUTPUT_VARIABLE FINAL_PATH_
                 )
-              execute_process(COMMAND "${CMAKE_COMMAND}" -E create_symlink "${FINAL_PATH_}" "${WDIR}/${F}")
+              execute_process(COMMAND "${CMAKE_COMMAND}" -E create_symlink
+                "${FINAL_PATH_}" "${WDIR}/${F}"
+                RESULT_VARIABLE _result_symlink_creation)
             else()
               # relocation subpaths
               cpack_rpm_symlink_add_for_relocation_script("${PACKAGE_PREFIXES}" "${F}" "${SYMLINK_RELOCATIONS}"
@@ -598,7 +601,9 @@ function(cpack_rpm_prepare_install_files INSTALL_FILES_LIST WDIR PACKAGE_PREFIXE
               "${SYMLINK_POINT_WD_}" "${POINT_RELOCATIONS}")
         else()
           # is not relocatable or points to non relocatable path - permanent symlink
-          execute_process(COMMAND "${CMAKE_COMMAND}" -E create_symlink "${SYMLINK_POINT_WD_}" "${WDIR}/${F}")
+          execute_process(COMMAND "${CMAKE_COMMAND}" -E create_symlink
+            "${SYMLINK_POINT_WD_}" "${WDIR}/${F}"
+            RESULT_VARIABLE _result_symlink_creation)
         endif()
       endif()
     elseif(IS_DIRECTORY "${WDIR}/${F}")
@@ -840,7 +845,8 @@ function(cpack_rpm_generate_package)
   execute_process(COMMAND ${RPMBUILD_EXECUTABLE} --version
                   OUTPUT_VARIABLE _TMP_VERSION
                   ERROR_QUIET
-                  OUTPUT_STRIP_TRAILING_WHITESPACE)
+                  OUTPUT_STRIP_TRAILING_WHITESPACE
+                  RESULT_VARIABLE _TMP_VERSION_RESULT)
   string(REGEX REPLACE "^.* " ""
          RPMBUILD_EXECUTABLE_VERSION
          ${_TMP_VERSION})
@@ -857,7 +863,8 @@ function(cpack_rpm_generate_package)
       execute_process(COMMAND ${LSB_RELEASE_EXECUTABLE} -a
                       OUTPUT_VARIABLE _TMP_LSB_RELEASE_OUTPUT
                       ERROR_QUIET
-                      OUTPUT_STRIP_TRAILING_WHITESPACE)
+                      OUTPUT_STRIP_TRAILING_WHITESPACE
+                      RESULT_VARIABLE _TMP_LSB_RELEASE_RESULT)
       string(REGEX REPLACE "\n" ", "
              LSB_RELEASE_OUTPUT
              ${_TMP_LSB_RELEASE_OUTPUT})
@@ -953,7 +960,8 @@ function(cpack_rpm_generate_package)
   if(NOT CPACK_RPM_PACKAGE_ARCHITECTURE)
     execute_process(COMMAND uname "-m"
                     OUTPUT_VARIABLE CPACK_RPM_PACKAGE_ARCHITECTURE
-                    OUTPUT_STRIP_TRAILING_WHITESPACE)
+                    OUTPUT_STRIP_TRAILING_WHITESPACE
+                    RESULT_VARIABLE _TMP_UNAME_RESULT)
   else()
     if(CPACK_RPM_PACKAGE_DEBUG)
       message("CPackRPM:Debug: using user-specified build arch = ${CPACK_RPM_PACKAGE_ARCHITECTURE}")
@@ -1113,7 +1121,8 @@ function(cpack_rpm_generate_package)
     execute_process(
       COMMAND "${RPM_EXECUTABLE}" --querytags
       OUTPUT_VARIABLE RPMBUILD_TAG_LIST
-      OUTPUT_STRIP_TRAILING_WHITESPACE)
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      RESULT_VARIABLE _result_rpm)
   endif()
   string(REPLACE "\n" ";" RPMBUILD_TAG_LIST "${RPMBUILD_TAG_LIST}")
 
@@ -1668,6 +1677,7 @@ ${TMP_DEBUGINFO_ADDITIONAL_SOURCES}
     execute_process(
         COMMAND ${CMAKE_COMMAND} -E tar "cfvz" "${CPACK_RPM_DIRECTORY}/SOURCES/${archive_name_}.tar.gz" "${CPACK_PACKAGE_FILE_NAME}"
         WORKING_DIRECTORY ${CPACK_RPM_DIRECTORY}
+        RESULT_VARIABLE _result_tar
       )
     set(TMP_RPM_SOURCE "Source: ${archive_name_}.tar.gz")
 
diff --git a/Modules/SquishTestScript.cmake b/Modules/SquishTestScript.cmake
index 9575084cdb..d74b03e934 100644
--- a/Modules/SquishTestScript.cmake
+++ b/Modules/SquishTestScript.cmake
@@ -45,7 +45,7 @@ endif ()
 
 if(squish_pre_command)
   message(STATUS "Executing pre command: ${squish_pre_command}")
-  execute_process(COMMAND "${squish_pre_command}")
+  execute_process(COMMAND "${squish_pre_command}" RESULT_VARIABLE _result_pre_command)
 endif()
 
 # run the test
@@ -71,7 +71,7 @@ endif()
 
 if(squish_post_command)
   message(STATUS "Executing post command: ${squish_post_command}")
-  execute_process(COMMAND "${squish_post_command}")
+  execute_process(COMMAND "${squish_post_command}" RESULT_VARIABLE _result_post_command)
 endif()
 
 # check for an error with running the test
diff --git a/Modules/UseJava/Symlinks.cmake b/Modules/UseJava/Symlinks.cmake
index 3142dca177..6281067d1b 100644
--- a/Modules/UseJava/Symlinks.cmake
+++ b/Modules/UseJava/Symlinks.cmake
@@ -13,6 +13,7 @@ if (UNIX AND _JAVA_TARGET_OUTPUT_LINK)
         execute_process(
             COMMAND ${LN_EXECUTABLE} -sf "${_JAVA_TARGET_OUTPUT_NAME}" "${_JAVA_TARGET_OUTPUT_LINK}"
             WORKING_DIRECTORY ${_JAVA_TARGET_DIR}
+            RESULT_VARIABLE _result_symlink_creation
         )
     else ()
         message(SEND_ERROR "FATAL: Can't find _JAVA_TARGET_OUTPUT_NAME")
diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt
index 210363e5a5..0520a5f0ec 100644
--- a/Tests/CMakeLists.txt
+++ b/Tests/CMakeLists.txt
@@ -1218,7 +1218,8 @@ if(BUILD_TESTING)
         execute_process(COMMAND ${CMAKE_COMMAND} -E env LC_ALL=C ${SHLIBDEPS_EXECUTABLE} --version
           OUTPUT_VARIABLE _TMP_VERSION
           ERROR_QUIET
-          OUTPUT_STRIP_TRAILING_WHITESPACE)
+          OUTPUT_STRIP_TRAILING_WHITESPACE
+          RESULT_VARIABLE _result_dpkg_version)
         if(_TMP_VERSION MATCHES "dpkg-shlibdeps version ([0-9]+\\.[0-9]+\\.[0-9]+)")
           set(SHLIBDEPS_EXECUTABLE_VERSION "${CMAKE_MATCH_1}")
         else()
@@ -1963,6 +1964,7 @@ if(BUILD_TESTING)
         COMMAND sw_vers -productVersion
         OUTPUT_VARIABLE OSX_VERSION
         OUTPUT_STRIP_TRAILING_WHITESPACE
+        RESULT_VARIABLE _sw_vers_result
         )
       if(OSX_VERSION MATCHES "^([0-9]+\\.[0-9]+)")
         set(CMake_TEST_XCTest_DEPLOYMENT_TARGET "${CMAKE_MATCH_1}")
diff --git a/Tests/RunCMake/CMakeLists.txt b/Tests/RunCMake/CMakeLists.txt
index 8bf0af3f82..bd18d1103c 100644
--- a/Tests/RunCMake/CMakeLists.txt
+++ b/Tests/RunCMake/CMakeLists.txt
@@ -1355,7 +1355,9 @@ endif()
 if(CMAKE_SYSTEM_PROCESSOR STREQUAL "e2k" AND NOT DEFINED CMake_TEST_E2K_BROKEN_LIBC)
   # Exclude tests that fail due to a broken libc version on Elbrus.
   find_program(DPKG_QUERY "dpkg-query" )
-  execute_process(COMMAND "${DPKG_QUERY}" "-f" "\${Version}" "-W" "glibc" OUTPUT_VARIABLE LIBC_VERSION)
+  execute_process(COMMAND "${DPKG_QUERY}" "-f" "\${Version}" "-W" "glibc"
+    OUTPUT_VARIABLE LIBC_VERSION
+    RESULT_VARIABLE _result_libc)
   if(LIBC_VERSION MATCHES "2.29-25.*")
     list(REMOVE_ITEM cpack_tests
       DEB.DEFAULT_PERMISSIONS