cmake execute_process examples

Signatures

execute_process(COMMAND <cmd1> [<arguments>]
  [COMMAND <cmd2> [<arguments>]]...
  [WORKING_DIRECTORY <directory>]
  [TIMEOUT <seconds>]
  [RESULT_VARIABLE <variable>]
  [RESULTS_VARIABLE <variable>]
  [OUTPUT_VARIABLE <variable>]
  [ERROR_VARIABLE <variable>]
  [INPUT_FILE <file>]
  [OUTPUT_FILE <file>]
  [ERROR_FILE <file>]
  [OUTPUT_QUIET]
  [ERROR_QUIET]
  [COMMAND_ECHO <where>]
  [OUTPUT_STRIP_TRAILING_WHITESPACE]
  [ERROR_STRIP_TRAILING_WHITESPACE]
  [ENCODING <name>]
  [ECHO_OUTPUT_VARIABLE]
  [ECHO_ERROR_VARIABLE]
[COMMAND_ERROR_IS_FATAL <ANY|LAST>])

Examples

geodynamics/aspect contrib/world_builder/tests/C/run_C_tests.cmake :21 

execute_process(
  COMMAND ${TEST_PROGRAM} ${TEST_ARGS} 
  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/C/ 
  OUTPUT_FILE ${TEST_OUTPUT}
  ERROR_VARIABLE TEST_ERROR_VAR
  RESULT_VARIABLE TEST_RESULT_VAR
  OUTPUT_VARIABLE TEST_OUTPUT_VAR
  )

o3de/o3de cmake/LYPython.cmake :196 

execute_process(COMMAND 
        ${LY_PYTHON_CMD} -m pip check
        WORKING_DIRECTORY ${LY_ROOT_FOLDER}/python
        RESULT_VARIABLE PIP_RESULT
        OUTPUT_VARIABLE PIP_OUT 
        ERROR_VARIABLE PIP_OUT
        )

godlikepanos/anki-3d-engine ThirdParty/Sdl3/cmake/sdlchecks.cmake :522 

execute_process(
        COMMAND ${WAYLAND_SCANNER} --version
        RESULT_VARIABLE WAYLAND_SCANNER_VERSION_RC
        ERROR_VARIABLE WAYLAND_SCANNER_VERSION_STDERR
        ERROR_STRIP_TRAILING_WHITESPACE
      )

cadaver/turso3d ThirdParty/SDL/cmake/macros.cmake :88 

execute_process(COMMAND ${CMAKE_LINKER} -v OUTPUT_VARIABLE LINKER_OUTPUT ERROR_VARIABLE LINKER_OUTPUT)

Hork-Engine/Hork-Source ThirdParty/SDL3/cmake/macros.cmake :88 

execute_process(COMMAND ${CMAKE_LINKER} -v OUTPUT_VARIABLE LINKER_OUTPUT ERROR_VARIABLE LINKER_OUTPUT)

RavEngine/RavEngine deps/SDL/cmake/macros.cmake :116 

execute_process(
            COMMAND "${CMAKE_DLLTOOL}" --identify "${IMPLIB}"
            RESULT_VARIABLE retcode
            OUTPUT_VARIABLE stdout
            ERROR_VARIABLE stderr)

cnr-isti-vclab/meshlab unsupported/plugins_unsupported/external/CoMISo/cmake/FindMPI.cmake :253 

execute_process(
            COMMAND ${MPI_${lang}_COMPILER} -link-info
            OUTPUT_VARIABLE  MPI_LINK_CMDLINE OUTPUT_STRIP_TRAILING_WHITESPACE
            ERROR_VARIABLE   MPI_LINK_CMDLINE ERROR_STRIP_TRAILING_WHITESPACE
            RESULT_VARIABLE  MPI_COMPILER_RETURN)

Vhonowslend/StreamFX-Public CMakeLists.txt :208 

execute_process(COMMAND "${GIT}" rev-list --count HEAD WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} RESULT_VARIABLE GIT_RESULT OUTPUT_VARIABLE GIT_OUTPUT ERROR_VARIABLE GIT_ERROR OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_STRIP_TRAILING_WHITESPACE ERROR_QUIET)

LLNL/zfp python/scikit-build-cmake/FindCython.cmake :61 

execute_process(COMMAND ${CYTHON_version_command}
                  OUTPUT_VARIABLE CYTHON_version_output
                  ERROR_VARIABLE CYTHON_version_error
                  RESULT_VARIABLE CYTHON_version_result
                  OUTPUT_STRIP_TRAILING_WHITESPACE
                  ERROR_STRIP_TRAILING_WHITESPACE)

CNES/MAJA Packaging/detect_using_file_command.cmake :21 

execute_process(COMMAND "${FILE_COMMAND}" "${input_file}"
    RESULT_VARIABLE file_rv
    OUTPUT_VARIABLE file_ov
    ERROR_VARIABLE file_ev
    OUTPUT_STRIP_TRAILING_WHITESPACE
    )

ANTsX/ANTs CMake/GetGitRevisionDescription.cmake :50 

execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse --git-dir
		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
		OUTPUT_VARIABLE GIT_DIR
		ERROR_VARIABLE error
		RESULT_VARIABLE failed
		OUTPUT_STRIP_TRAILING_WHITESPACE
		)

Kitware/kwiver .gitlab/ci/download_qt.cmake :105 

execute_process(
    # Remove any read-only flags that aren't affected by `icacls`.
    COMMAND
      attrib
      -r # Remove readonly flag
      "${native_qt_dir}"
      /d # Treat as a directory
      /s # Recursive
      /l # Don't dereference symlinks
    RESULT_VARIABLE res
    ERROR_VARIABLE err
    ERROR_STRIP_TRAILING_WHITESPACE)

nv-legate/legate src/cmake/scripts/external_clang_tidy.cmake :54 

execute_process(COMMAND ${CLANG_TIDY} --extra-arg=${mode_flag} -p "${BUILD_DIR}"
                              "${src}"
                      COMMAND "${SED}" -E ${_LEGATE_TIDY_SED_RX} #
                      WORKING_DIRECTORY "${BUILD_DIR}"
                      OUTPUT_VARIABLE _out
                      ERROR_VARIABLE _out RESULTS_VARIABLE _statuses
                      OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_STRIP_TRAILING_WHITESPACE)

mariadb-corporation/MaxScale CMakeLists.txt :124 

execute_process(COMMAND ${GIT_EXECUTABLE} rev-list --max-count=1 HEAD
    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
    OUTPUT_VARIABLE GIT_COMMIT
    ERROR_VARIABLE GIT_ERROR
    RESULT_VARIABLE GIT_RVAL)

openvinotoolkit/openvino cmake/developer_package/api_validator/api_validator_run.cmake :33 

execute_process(COMMAND ${command}
                OUTPUT_VARIABLE output_message
                ERROR_VARIABLE error_message
                RESULT_VARIABLE exit_code
                OUTPUT_STRIP_TRAILING_WHITESPACE)

gnss-sdr/gnss-sdr src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/CMakeLists.txt :36 

execute_process(COMMAND
        ${CMAKE_CXX_COMPILER} -v
        RESULT_VARIABLE _res ERROR_VARIABLE _err
        ERROR_STRIP_TRAILING_WHITESPACE)

openthread/openthread third_party/mbedtls/repo/CMakeLists.txt :151 

execute_process(COMMAND ln -s ${target} ${link}
                RESULT_VARIABLE result
                ERROR_VARIABLE output)

SsageParuders/Android_Native_Surface my_android_opencv/cmake/android/android_ant_projects.cmake :20 

execute_process(COMMAND ${ANDROID_EXECUTABLE} list target -c
  RESULT_VARIABLE ANDROID_PROCESS
  OUTPUT_VARIABLE ANDROID_SDK_TARGETS
  ERROR_VARIABLE ANDROID_PROCESS_ERRORS
  OUTPUT_STRIP_TRAILING_WHITESPACE
  )

ossia/score cmake/modules/FindFaust.cmake :53 

execute_process(COMMAND ${LLVM_CONFIG} "--includedir"
          OUTPUT_VARIABLE LLVM_DIR
          ERROR_VARIABLE LLVM_CONFIG_STDERR
          RESULT_VARIABLE LLVM_ERROR
      )

lizardfs/lizardfs cmake/DownloadExternal.cmake :32 

execute_process(COMMAND unzip -q ${CMAKE_BINARY_DIR}/${PCKG_DIR_NAME}.zip
      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/external
      RESULT_VARIABLE UNZIP_ERROR
      ERROR_VARIABLE UNZIP_ERROR_MESSAGE)

AcademySoftwareFoundation/MaterialX source/PyMaterialX/External/PyBind11/tools/pybind11NewTools.cmake :150 

execute_process(
      COMMAND
        "${${_Python}_EXECUTABLE}" "-c"
        "import sys, importlib; s = importlib.import_module('distutils.sysconfig' if sys.version_info < (3, 10) else 'sysconfig'); print(s.get_config_var('EXT_SUFFIX') or s.get_config_var('SO'))"
      OUTPUT_VARIABLE _PYTHON_MODULE_EXT_SUFFIX
      ERROR_VARIABLE _PYTHON_MODULE_EXT_SUFFIX_ERR
      OUTPUT_STRIP_TRAILING_WHITESPACE)

w111liang222/lidar-slam-detection third_party/pybind11/tools/FindPythonLibsNew.cmake :113 

execute_process(
  COMMAND
    "${PYTHON_EXECUTABLE}" "-c" "
import sys;import struct;
import sysconfig as s
USE_SYSCONFIG = sys.version_info >= (3, 10)
if not USE_SYSCONFIG:
    from distutils import sysconfig as ds
print('.'.join(str(v) for v in sys.version_info));
print(sys.prefix);
if USE_SYSCONFIG:
    scheme = s.get_default_scheme()
    if scheme == 'posix_local':
        # Debian's default scheme installs to /usr/local/ but we want to find headers in /usr/
        scheme = 'posix_prefix'
    print(s.get_path('platinclude', scheme))
    print(s.get_path('platlib'))
else:
    print(ds.get_python_inc(plat_specific=True));
    print(ds.get_python_lib(plat_specific=True));
print(s.get_config_var('EXT_SUFFIX') or s.get_config_var('SO'));
print(hasattr(sys, 'gettotalrefcount')+0);
print(struct.calcsize('@P'));
print(s.get_config_var('LDVERSION') or s.get_config_var('VERSION'));
print(s.get_config_var('LIBDIR') or '');
print(s.get_config_var('MULTIARCH') or '');
"
  RESULT_VARIABLE _PYTHON_SUCCESS
  OUTPUT_VARIABLE _PYTHON_VALUES
  ERROR_VARIABLE _PYTHON_ERROR_VALUE)

LiangliangNan/MVStudio 3rd_party/nlopt/cmake/FindNumPy.cmake :48 

execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c"
    "import numpy as np; print(np.__version__); print(np.get_include());"
    RESULT_VARIABLE _NUMPY_SEARCH_SUCCESS
    OUTPUT_VARIABLE _NUMPY_VALUES_OUTPUT
    ERROR_VARIABLE _NUMPY_ERROR_VALUE
    OUTPUT_STRIP_TRAILING_WHITESPACE)

Kitware/ParaView .gitlab/ci/download_python.cmake :34 

execute_process(
  COMMAND
    "${CMAKE_COMMAND}"
    -E tar
    xf "${filename}"
  WORKING_DIRECTORY ".gitlab"
  RESULT_VARIABLE res
  ERROR_VARIABLE err
  ERROR_STRIP_TRAILING_WHITESPACE)

rakhimov/scram gui/CMakeLists.txt :29 

execute_process(
    COMMAND python generate_rcc.py icons/tango/index.theme
    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/qtango
    RESULT_VARIABLE qtango_return
    OUTPUT_VARIABLE qtango_out
    ERROR_VARIABLE qtango_out
    )

marsyas/marsyas cmake-modules/FindPythonInterp.cmake :47 

EXECUTE_PROCESS(COMMAND ${PythonInterp_EXECUTABLE}
    -c  "import sys; print sys.version"
    OUTPUT_VARIABLE PYTHONINTERP_version_output
    ERROR_VARIABLE PYTHONINTERP_version_error
    RESULT_VARIABLE PYTHONINTERP_version_result
    OUTPUT_STRIP_TRAILING_WHITESPACE)

DIPlib/diplib tools/FindMatlab.cmake :788 

execute_process(
    COMMAND "${matlab_binary_program}" -nosplash -nojvm ${_matlab_additional_commands} -logfile "matlabVersionLog.cmaketmp" -nodesktop -nodisplay -r "version, exit"
    OUTPUT_VARIABLE _matlab_version_from_cmd_dummy
    RESULT_VARIABLE _matlab_result_version_call
    ERROR_VARIABLE _matlab_result_version_call_error
    TIMEOUT 120
    WORKING_DIRECTORY "${_matlab_temporary_folder}"
    ${devnull}
    )

BRAINSia/BRAINSTools CMake/GetGitRevisionDescription.cmake :92 

execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse HEAD
		WORKING_DIRECTORY ${src_dir}
		OUTPUT_VARIABLE HEAD_HASH OUTPUT_STRIP_TRAILING_WHITESPACE
		ERROR_VARIABLE error
		RESULT_VARIABLE failed)

Tulip-Dev/tulip cmake/FindSphinx.cmake :26 

EXECUTE_PROCESS(COMMAND ${PYTHON_EXECUTABLE} --version OUTPUT_VARIABLE PYTHON_VERSION_RAW ERROR_VARIABLE PYTHON_VERSION_RAW)

gismo/gismo cmake/ctest_script.cmake :217 

execute_process(COMMAND ${CMAKE_COMMAND} -Wno-dev .
    ERROR_VARIABLE CTEST_CMAKE_GENERATOR
    OUTPUT_QUIET
    WORKING_DIRECTORY ${CTEST_BINARY_DIRECTORY}/cgtest/
    ERROR_STRIP_TRAILING_WHITESPACE)

Alpine-DAV/ascent src/cmake/thirdparty/SetupPython.cmake :111 

execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c"
                                    "import sys;from sysconfig import get_config_var; sys.stdout.write(get_config_var('LIBRARY'))"
                            OUTPUT_VARIABLE PYTHON_CONFIG_LIBRARY
                            ERROR_VARIABLE  ERROR_FINDING_PYTHON_LIBRARY)

SimVascular/SimVascular Code/CMake/SimVascularUseExternals.cmake :108 

execute_process(COMMAND bash "-c" "make"
  WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/Externals-build"
  OUTPUT_VARIABLE MAKE_OUTPUT
  RESULT_VARIABLE MAKE_RESULT
  ERROR_VARIABLE  MAKE_ERROR)

NERSC/timemory cmake/Modules/FindPython/Support.cmake :1980 

execute_process(
                        COMMAND
                            ${_${_PYTHON_PREFIX}_INTERPRETER_LAUNCHER}
                            "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c
                            "import sys; sys.stdout.write(str(sys.maxsize > 2**32))"
                        RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT
                        OUTPUT_VARIABLE ${_PYTHON_PREFIX}_IS64BIT
                        ERROR_VARIABLE ${_PYTHON_PREFIX}_IS64BIT)

GoSSIP-SJTU/TripleDoggy CMakeLists.txt :649 

execute_process(
  COMMAND ${PYTHON_EXECUTABLE} -B ${LLVMBUILDTOOL}
            --native-target "${LLVM_NATIVE_ARCH}"
            --enable-targets "${LLVM_TARGETS_TO_BUILD}"
            --enable-optional-components "${LLVMOPTIONALCOMPONENTS}"
            --write-library-table ${LLVMCONFIGLIBRARYDEPENDENCIESINC}
            --write-cmake-fragment ${LLVMBUILDCMAKEFRAG}
            OUTPUT_VARIABLE LLVMBUILDOUTPUT
            ERROR_VARIABLE LLVMBUILDERRORS
            OUTPUT_STRIP_TRAILING_WHITESPACE
            ERROR_STRIP_TRAILING_WHITESPACE
  RESULT_VARIABLE LLVMBUILDRESULT)

ceph/ceph cmake/modules/FindPython/Support.cmake :2161 

execute_process (COMMAND ${_${_PYTHON_PREFIX}_INTERPRETER_LAUNCHER} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c
                                   "import sys; sys.stdout.write(str(sys.maxsize > 2**32))"
                           RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT
                           OUTPUT_VARIABLE ${_PYTHON_PREFIX}_IS64BIT
                           ERROR_VARIABLE ${_PYTHON_PREFIX}_IS64BIT)

gnuradio/gnuradio cmake/Modules/FindTHRIFT.cmake :39 

execute_process(
    COMMAND ${THRIFT_BIN} --version
    OUTPUT_VARIABLE THRIFT_VERSION
    ERROR_VARIABLE THRIFT_VERSION_ERROR)

opensim-org/opensim-core cmake/FindMatlab.cmake :394 

execute_process(
    COMMAND reg query HKEY_LOCAL_MACHINE\\SOFTWARE\\Mathworks\\MATLAB /f * /k ${APPEND_REG}
    RESULT_VARIABLE resultMatlab
    OUTPUT_VARIABLE varMatlab
    ERROR_VARIABLE errMatlab
    INPUT_FILE NUL
    )

AcademySoftwareFoundation/openvdb openvdb_ax/openvdb_ax/test/TestAXCmd.cmake :41 

execute_process(COMMAND ${Python_EXECUTABLE} ${DOWNLOAD_SCRIPT} -f sphere.vdb torus.vdb sphere_points.vdb
      OUTPUT_VARIABLE DOWNLOAD_OUTPUT
      ERROR_VARIABLE  DOWNLOAD_OUTPUT
      RESULT_VARIABLE RETURN_CODE)

STEllAR-GROUP/hpx cmake/HPX_UpdateGitDocs.cmake :44 

execute_process(
      COMMAND "${GIT_EXECUTABLE}" commit -am "Updating Sphinx docs - ${message}"
      WORKING_DIRECTORY "${HPX_BINARY_DIR}/docs/gh-pages"
      RESULT_VARIABLE git_commit_result
      ERROR_VARIABLE git_pull_result_message COMMAND_ECHO STDERR
    )

hlrs-vis/covise CMakeLists.txt :113 

execute_process(COMMAND ${GIT_EXECUTABLE} log -n1 --format=%h/%ci
      WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
      OUTPUT_VARIABLE GIT_LOG_OUT
      ERROR_VARIABLE GIT_LOG_ERROR
      RESULT_VARIABLE GIT_LOG_RESULT
      OUTPUT_STRIP_TRAILING_WHITESPACE)

vengi-voxel/vengi contrib/libs/sdl2/cmake/sdlchecks.cmake :666 

execute_process(
        COMMAND ${WAYLAND_SCANNER} --version
        RESULT_VARIABLE WAYLAND_SCANNER_VERSION_RC
        ERROR_VARIABLE WAYLAND_SCANNER_VERSION
        ERROR_STRIP_TRAILING_WHITESPACE
      )

root-project/root cmake/modules/CheckAssembler.cmake :9 

execute_process(COMMAND ${CMAKE_CXX_COMPILER} -print-prog-name=as OUTPUT_VARIABLE _as ERROR_VARIABLE _as OUTPUT_STRIP_TRAILING_WHITESPACE)

scylladb/scylladb cmake/mode.common.cmake :70 

execute_process(
    COMMAND ${CMAKE_C_COMPILER} "-###" /dev/null -o t
    ERROR_VARIABLE driver_command_line
    ERROR_STRIP_TRAILING_WHITESPACE)

toggl-open-source/toggldesktop third_party/poco/cmake/ExecuteOnAndroid.cmake :14 

execute_process(
   COMMAND ${ANDROID_NDK}/../platform-tools/adb shell "cd /data/local/tmp;su root sh -c 'LD_LIBRARY_PATH=/data/local/tmp/lib TMPDIR=/data/local/tmp HOME=/data/local/tmp ./${UNITTEST_FILENAME} ${TEST_PARAMETER};echo exit code $?'"
   RESULT_VARIABLE _RESULT
   OUTPUT_VARIABLE _OUT
   ERROR_VARIABLE _ERR
)

Slicer/Slicer CMake/SlicerFunctionGetGccVersion.cmake :23 

execute_process(
      COMMAND ${path_to_gcc} -dumpversion
      RESULT_VARIABLE result
      OUTPUT_VARIABLE output
      ERROR_VARIABLE error
      OUTPUT_STRIP_TRAILING_WHITESPACE
      ERROR_STRIP_TRAILING_WHITESPACE
      )

google/filament third_party/dawn/third_party/dxc/CMakeLists.txt :484 

execute_process(
  COMMAND ${Python3_EXECUTABLE} ${LLVMBUILDTOOL}
            --native-target Unknown
            --enable-targets "${LLVM_TARGETS_TO_BUILD}"
            --enable-optional-components "${LLVMOPTIONALCOMPONENTS}"
            --write-library-table ${LLVMCONFIGLIBRARYDEPENDENCIESINC}
            --write-cmake-fragment ${LLVMBUILDCMAKEFRAG}
            OUTPUT_VARIABLE LLVMBUILDOUTPUT
            ERROR_VARIABLE LLVMBUILDERRORS
            OUTPUT_STRIP_TRAILING_WHITESPACE
            ERROR_STRIP_TRAILING_WHITESPACE
  RESULT_VARIABLE LLVMBUILDRESULT)

percona/percona-xtrabackup cmake/fastcov.cmake :72 

EXECUTE_PROCESS(
  COMMAND ${GCOV_EXECUTABLE} --version
  OUTPUT_VARIABLE stdout
  ERROR_VARIABLE  stderr
  RESULT_VARIABLE result
  OUTPUT_STRIP_TRAILING_WHITESPACE
)

NREL/EnergyPlus third_party/libtk205/vendor/json/cmake/ci.cmake :70 

execute_process(COMMAND ${OCLINT_VERSION_TOOL} --version OUTPUT_VARIABLE OCLINT_TOOL_VERSION ERROR_VARIABLE OCLINT_TOOL_VERSION)

mysql/mysql-server cmake/maven.cmake :56 

EXECUTE_PROCESS(COMMAND ${MAVEN_EXECUTABLE} --version
      OUTPUT_VARIABLE MAVEN_VERSION_OUTPUT
      ERROR_VARIABLE MAVEN_VERSION_OUTPUT)

philip82148/cpp-dump test/color_indent_test.cmake :24 

execute_process(
   COMMAND "${cmd_path}" "${width}" "${depth}" "${es_style}" 1 ERROR_VARIABLE error_contents COMMAND_ERROR_IS_FATAL ANY
)

apache/kudu cmake_modules/CompilerInfo.cmake :20 

execute_process(COMMAND env LANG=C "${CMAKE_CXX_COMPILER}" -v
                ERROR_VARIABLE COMPILER_VERSION_FULL)

Icinga/icinga2 CMakeLists.txt :158 

execute_process(COMMAND ${LOGROTATE_BINARY} ERROR_VARIABLE LOGROTATE_OUTPUT)

stanford-centaur/smt-switch cmake/CheckPythonModule.cmake :75 

execute_process(
        COMMAND
            ${Python_EXECUTABLE} -c "import ${module}; print(${module}.__version__ if hasattr(${module}, '__version__') else '')"
        RESULT_VARIABLE
            _${module}_version_status
        OUTPUT_VARIABLE
            _${module}_version
        ERROR_VARIABLE
            _${module}_version_error
        ERROR_STRIP_TRAILING_WHITESPACE
        OUTPUT_STRIP_TRAILING_WHITESPACE
    )

eclipse-upm/upm cmake/modules/FindUpmCordovaGenerator.cmake :8 

execute_process(COMMAND ${NPM_EXECUTABLE} info upm-cordova-binding version
        OUTPUT_VARIABLE UPM_CORDOVA_BINDING_VERSION
        ERROR_VARIABLE UPM_CORDOVA_BINDING_VERSION
        OUTPUT_STRIP_TRAILING_WHITESPACE
        ERROR_STRIP_TRAILING_WHITESPACE)

pytorch/FBGEMM CMakeLists.txt :31 

execute_process(
    COMMAND "${Python_EXECUTABLE}" -c
            "exec(open('defs.bzl').read());print(';'.join(${name}))"
    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
    OUTPUT_VARIABLE _tempvar
    RESULT_VARIABLE _resvar
    ERROR_VARIABLE _errvar)

LLNL/axom src/cmake/thirdparty/SetupAxomThirdParty.cmake :241 

execute_process(COMMAND ${SHROUD_EXECUTABLE}
                    --cmake ${CMAKE_CURRENT_BINARY_DIR}/SetupShroud.cmake
                    ERROR_VARIABLE SHROUD_cmake_error
                    RESULT_VARIABLE SHROUD_cmake_result
                    OUTPUT_STRIP_TRAILING_WHITESPACE )

prophesee-ai/openeb cmake/custom_functions/add_library_version_header.cmake :79 

execute_process(
    COMMAND \${cmd}
    OUTPUT_VARIABLE GIT_COMMIT_DATE
    OUTPUT_STRIP_TRAILING_WHITESPACE
    ERROR_VARIABLE err
    RESULT_VARIABLE ret
)

mysql/mysql-connector-cpp testing/find_package/run_test.cmake :199 

execute_process(
        COMMAND ${LDD_COMMAND} "${exec_path}"
        OUTPUT_VARIABLE foo
        ERROR_VARIABLE foo
      #  ECHO_OUTPUT_VARIABLE  # note: not available in 3.15
      )

malaterre/GDCM CMake/UseJavaTest.cmake :83 

execute_process(
    #COMMAND ${Java_JAVA_EXECUTABLE} -Djava.library.path=\"${GDCM_LIBRARY_DIR}\" -classpath \"${classpath}\" ${loc2} ${wo_semicolumn}
    COMMAND ${Java_JAVA_EXECUTABLE} -classpath \"${classpath}\" ${loc2} ${wo_semicolumn}
    WORKING_DIRECTORY \"${EXECUTABLE_OUTPUT_PATH}\"
    RESULT_VARIABLE import_res
    OUTPUT_VARIABLE import_output
    ERROR_VARIABLE  import_output
  )

KiCad/kicad-source-mirror cmake/FindSWIG.cmake :61 

execute_process(COMMAND ${SWIG_EXECUTABLE} -swiglib
    OUTPUT_VARIABLE SWIG_swiglib_output
    ERROR_VARIABLE SWIG_swiglib_error
    RESULT_VARIABLE SWIG_swiglib_result)

BioMedIA/MIRTK CMake/Modules/FindSphinx.cmake :172 

execute_process (
      COMMAND "${Sphinx_PYTHON_EXECUTABLE}" ${Sphinx_PYTHON_OPTIONS} "${Sphinx-build_EXECUTABLE}" -h
      OUTPUT_VARIABLE _Sphinx_VERSION
      ERROR_VARIABLE  _Sphinx_VERSION
    )

sonosaurus/sonobus JUCE/extras/Build/juceaide/CMakeLists.txt :78 

execute_process(COMMAND "${CMAKE_COMMAND}"
            --build "${JUCE_BINARY_DIR}/tools"
            --config Debug
        OUTPUT_VARIABLE command_output
        ERROR_VARIABLE command_output
        RESULT_VARIABLE result_variable)

monadgroup/axiom cmake/modules/BundleUtilities.cmake :828 

execute_process(COMMAND install_name_tool
    OUTPUT_VARIABLE install_name_tool_usage
    ERROR_VARIABLE  install_name_tool_usage
    )

qt/qtbase cmake/QtPublicWasmToolchainHelpers.cmake :34 

execute_process(COMMAND ${EXECUTE_COMMAND} --version
        OUTPUT_VARIABLE emOutput
        OUTPUT_STRIP_TRAILING_WHITESPACE
        ERROR_VARIABLE emrun_error
        RESULT_VARIABLE result)

microsoft/DirectXShaderCompiler tools/clang/test/taef_exec/DownloadWarp.cmake :58 

execute_process(
    COMMAND ${NUGET_EXE} install -ForceEnglishOutput Microsoft.Direct3D.WARP -OutputDirectory ${CMAKE_BINARY_DIR}/nuget ${NUGET_WARP_EXTRA_ARGS_LIST}
    RESULT_VARIABLE result
    OUTPUT_VARIABLE nuget_output
    ERROR_VARIABLE nuget_output)

qtfreet00/llvm-obfuscator CMakeLists.txt :645 

execute_process(
  COMMAND ${PYTHON_EXECUTABLE} -B ${LLVMBUILDTOOL}
            --native-target "${LLVM_NATIVE_ARCH}"
            --enable-targets "${LLVM_TARGETS_TO_BUILD}"
            --enable-optional-components "${LLVMOPTIONALCOMPONENTS}"
            --write-library-table ${LLVMCONFIGLIBRARYDEPENDENCIESINC}
            --write-cmake-fragment ${LLVMBUILDCMAKEFRAG}
            OUTPUT_VARIABLE LLVMBUILDOUTPUT
            ERROR_VARIABLE LLVMBUILDERRORS
            OUTPUT_STRIP_TRAILING_WHITESPACE
            ERROR_STRIP_TRAILING_WHITESPACE
  RESULT_VARIABLE LLVMBUILDRESULT)

jingma-git/RealSkel external/libigl/cmake/FindMATLAB.cmake :375 

execute_process(
    COMMAND reg query HKEY_LOCAL_MACHINE\\SOFTWARE\\Mathworks\\MATLAB /f * /k ${APPEND_REG}
    RESULT_VARIABLE resultMatlab
    OUTPUT_VARIABLE varMatlab
    ERROR_VARIABLE errMatlab
    INPUT_FILE NUL
    )

yrnkrn/zapcc CMakeLists.txt :647 

execute_process(
  COMMAND ${PYTHON_EXECUTABLE} -B ${LLVMBUILDTOOL}
            --native-target "${LLVM_NATIVE_ARCH}"
            --enable-targets "${LLVM_TARGETS_TO_BUILD}"
            --enable-optional-components "${LLVMOPTIONALCOMPONENTS}"
            --write-library-table ${LLVMCONFIGLIBRARYDEPENDENCIESINC}
            --write-cmake-fragment ${LLVMBUILDCMAKEFRAG}
            OUTPUT_VARIABLE LLVMBUILDOUTPUT
            ERROR_VARIABLE LLVMBUILDERRORS
            OUTPUT_STRIP_TRAILING_WHITESPACE
            ERROR_STRIP_TRAILING_WHITESPACE
  RESULT_VARIABLE LLVMBUILDRESULT)

jasp-stats/jasp-desktop Tools/CMake/R.cmake :529 

execute_process(
                #COMMAND_ECHO STDOUT
                #ERROR_QUIET
                OUTPUT_QUIET
                TIMEOUT 30
                WORKING_DIRECTORY ${R_HOME_PATH}
                COMMAND
                  codesign --force --verbose --deep ${CODESIGN_TIMESTAMP_FLAG} --sign
                  ${APPLE_CODESIGN_IDENTITY} 
                  "${R_HOME_PATH}/bin/exec/R"
                RESULT_VARIABLE SIGNING_RESULT
                OUTPUT_VARIABLE SIGNING_OUTPUT
                ERROR_VARIABLE SIGNING_ERROR)

Dreamtowards/Ethertia lib/json-nlohmann-3.11.2/cmake/ci.cmake :59 

execute_process(COMMAND ${LCOV_TOOL} --version OUTPUT_VARIABLE LCOV_TOOL_VERSION ERROR_VARIABLE LCOV_TOOL_VERSION)

ess-dmsc/h5cpp cmake/conan.cmake :949 

execute_process(COMMAND ${CONAN_CMD} --version
                    RESULT_VARIABLE return_code
                    OUTPUT_VARIABLE CONAN_VERSION_OUTPUT
                    ERROR_VARIABLE CONAN_VERSION_OUTPUT)

rbfx/rbfx CMake/Modules/CheckCompilerToolchain.cmake :160 

execute_process (COMMAND ${CMAKE_COMMAND} -E env CC=${SAVED_CC} CXX=${SAVED_CXX} ${CMAKE_COMMAND} -G${CMAKE_GENERATOR} -DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM} .
            WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/generated RESULT_VARIABLE EXIT_CODE ERROR_VARIABLE ERR_VAR OUTPUT_QUIET)

InsightSoftwareConsortium/ITK Modules/ThirdParty/HDF5/src/itkhdf5/config/cmake/grepTest.cmake :59 

execute_process (
    COMMAND ${TEST_EMULATOR} ${TEST_PROGRAM} ${TEST_ARGS}
    WORKING_DIRECTORY ${TEST_FOLDER}
    RESULT_VARIABLE TEST_RESULT
    OUTPUT_FILE ${TEST_OUTPUT}
    ERROR_FILE ${TEST_OUTPUT}.err
    OUTPUT_VARIABLE TEST_OUT
    ERROR_VARIABLE TEST_ERROR
)

ComputationalBiomechanicsLab/opensim-creator third_party/OpenBLAS/lapack-netlib/CMAKE/FortranMangling.cmake :45 

execute_process ( COMMAND  ${CMAKE_Fortran_COMPILER} ${F77_OPTION_COMPILE} ${PROJECT_SOURCE_DIR}/lapacke/mangling/Fintface.f
      WORKING_DIRECTORY  ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
      OUTPUT_VARIABLE    OUTPUT
      RESULT_VARIABLE    RESULT
      ERROR_VARIABLE     ERROR)

Warzone2100/warzone2100 cmake/FindNPM.cmake :17 

execute_process(COMMAND ${NPM_EXECUTABLE} prefix -g
		OUTPUT_VARIABLE NPM_GLOBAL_PREFIX_DIR
		ERROR_VARIABLE NPM_prefix_g_error
		RESULT_VARIABLE NPM_prefix_g_result_code
	)

Stellarium/stellarium CMakeLists.txt :171 

EXECUTE_PROCESS(COMMAND ${GIT_EXECUTABLE} describe --tags --abbrev=0 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} TIMEOUT 30 OUTPUT_VARIABLE GIT_TAGS OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_VARIABLE GIT_ERROR)

VcDevel/Vc cmake/VcMacros.cmake :44 

execute_process(COMMAND "${CMAKE_CXX_COMPILER}" "--version" OUTPUT_VARIABLE _cxx_compiler_version ERROR_VARIABLE _cxx_compiler_version)

chsl/PLADE code/3rd_party/opencv/cmake/OpenCVDetectPython.cmake :24 

execute_process(COMMAND ${PYTHON_EXECUTABLE} --version
      ERROR_VARIABLE PYTHON_VERSION_FULL
      ERROR_STRIP_TRAILING_WHITESPACE)

shogun-toolbox/shogun cmake/FindJinja2.cmake :2 

execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c"
	"from jinja2 import Template; "
	RESULT_VARIABLE JINJA2_SEARCH_SUCCESS
	OUTPUT_VARIABLE JINJA2_VALUES_OUTPUT
	ERROR_VARIABLE JINJA2_ERROR_VALUE
	OUTPUT_STRIP_TRAILING_WHITESPACE)

monero-project/monero cmake/CheckTrezor.cmake :140 

execute_process(COMMAND ${Protobuf_PROTOC_EXECUTABLE} --cpp_out "${_proto_out_dir}" "-I${_proto_include_dir}" ${_proto_files_absolute} RESULT_VARIABLE RET OUTPUT_VARIABLE OUT ERROR_VARIABLE ERR)

ornladios/ADIOS2 cmake/upstream/FindMPI.cmake :491 

execute_process(
      COMMAND ${CMAKE_MATCH_1} ${CMAKE_MATCH_2} ${MPI_${LANG}_COMPILER}
      OUTPUT_VARIABLE  COMPILER_CHECKER_OUTPUT OUTPUT_STRIP_TRAILING_WHITESPACE
      ERROR_VARIABLE   COMPILER_CHECKER_OUTPUT ERROR_STRIP_TRAILING_WHITESPACE
      RESULT_VARIABLE  MPI_COMPILER_RETURN)

BoomerangDecompiler/boomerang cmake-scripts/boomerang-utils.cmake :359 

execute_process(COMMAND "cmd" /C "${LNK_COMMAND}"
            WORKING_DIRECTORY "${BOOMERANG_OUTPUT_DIR}"
            OUTPUT_QUIET
            ERROR_VARIABLE LNK_ERROR
            ERROR_STRIP_TRAILING_WHITESPACE
        )

fktn-k/fkYAML tests/unit_test/CMakeLists.txt :8 

execute_process(
    COMMAND ${LCOV_TOOL} --version
    OUTPUT_VARIABLE LCOV_TOOL_VERSION
    ERROR_VARIABLE LCOV_TOOL_VERSION
  )

mosra/magnum-plugins src/Magnum/CMakeLists.txt :34 

execute_process(COMMAND ${GIT_EXECUTABLE} describe --match "v*" --long
        OUTPUT_VARIABLE MAGNUMPLUGINS_VERSION_STRING
        RESULT_VARIABLE _MAGNUMPLUGINS_VERSION_RESULT
        ERROR_VARIABLE _MAGNUMPLUGINS_VERSION_ERROR
        # Otherwise this gets executed in the build dir, which might be inside
        # a totally different Git working copy. But that's not enough, if it
        # would be run in ${CMAKE_CURRENT_SOURCE_DIR}, on Windows the
        # `--match "v*"` would get expanded to the `versionPlugins.h.cmake`
        # file, causing Git to obviously not find any such tag. The reason is
        # probably that on Windows the wildcard expansion is done on the
        # application side and not by the shell, thus being performed even
        # though CMake docs say `execute_process()` doesn't involve a shell.
        # The package/git directory is thus dedicated for that operation,
        # *guaranteed* to never contain any file starting with `v` (or `V` for
        # that matter because, again, HELLO WINDOWS).
        WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/package/git
        OUTPUT_STRIP_TRAILING_WHITESPACE)

sandialabs/Albany doc/dashboards/attaway-login10/ctest_nightly_albany_intel_serial_run.cmake :157 

execute_process (COMMAND "${CTEST_GIT_COMMAND}" pull
      WORKING_DIRECTORY ${CTEST_SOURCE_DIRECTORY}/Albany
      OUTPUT_VARIABLE _out
      ERROR_VARIABLE _err
      RESULT_VARIABLE HAD_ERROR)

symforce-org/symforce third_party/symengine/cmake/cotire.cmake :1226 

execute_process(
		COMMAND ${_cmd}
		WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
		RESULT_VARIABLE _result
		OUTPUT_QUIET
		ERROR_VARIABLE _output)

commontk/CTK CMake/ctkFunctionAddPluginRepo.cmake :43 

execute_process(
        COMMAND ${GIT_EXECUTABLE} submodule update ${_plugin_name}
        WORKING_DIRECTORY ${${_NAME}_DIR}
        RESULT_VARIABLE return_code
        ERROR_VARIABLE error_msg
      )

intel/systemc-compiler systemc/cmake/run-example.cmake :80 

execute_process(COMMAND ${TEST_EXE}
                  WORKING_DIRECTORY ${TEST_DIR}
                  RESULT_VARIABLE TEST_EXIT_CODE
                  OUTPUT_FILE run.log
                  ERROR_VARIABLE TEST_ERROR)

sxs-collaboration/spectre cmake/FindCharm.cmake :354 

execute_process(
  COMMAND
  bash -c "(${CHARM_MODULEINIT_CMD} || mv moduleinit*.C CharmModuleInit.C) \
    && rm moduleinit*"
  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/tmp/
  ERROR_VARIABLE CHARM_MODULEINIT_ERROR
  )

securesystemslab/multicompiler CMakeLists.txt :465 

execute_process(
  COMMAND ${PYTHON_EXECUTABLE} ${LLVMBUILDTOOL}
            --native-target "${LLVM_NATIVE_ARCH}"
            --enable-targets "${LLVM_TARGETS_TO_BUILD}"
            --enable-optional-components "${LLVMOPTIONALCOMPONENTS}"
            --write-library-table ${LLVMCONFIGLIBRARYDEPENDENCIESINC}
            --write-cmake-fragment ${LLVMBUILDCMAKEFRAG}
            OUTPUT_VARIABLE LLVMBUILDOUTPUT
            ERROR_VARIABLE LLVMBUILDERRORS
            OUTPUT_STRIP_TRAILING_WHITESPACE
            ERROR_STRIP_TRAILING_WHITESPACE
  RESULT_VARIABLE LLVMBUILDRESULT)

mysql/mysql-shell cmake/ssl.cmake :179 

EXECUTE_PROCESS(COMMAND ${PKG_CONFIG_EXECUTABLE} --libs ${WITH_SSL}
    OUTPUT_STRIP_TRAILING_WHITESPACE
    OUTPUT_VARIABLE OPENSSL_NN_LIBS
    RESULT_VARIABLE OPENSSL_NN_LIBS_RESULT
    ERROR_VARIABLE OPENSSL_NN_LIBS_ERROR
    )

borisbrodski/sevenzipjbinding scripts/integration-test/doITTests.cmake :167 

EXECUTE_PROCESS(COMMAND ${SEVEN_ZIP} -y x "${RELEASE_NAME}.zip"
                        WORKING_DIRECTORY "${ITTEST_DIR}"
                        RESULT_VARIABLE archive_result
                        OUTPUT_VARIABLE archive_output 
                        ERROR_VARIABLE archive_err)

kpeeters/cadabra2 cmake/modules/cotire.cmake :69 

execute_process (
				COMMAND ${CMAKE_${_language}_COMPILER} ${_compilerArg1}
				ERROR_VARIABLE _versionLine OUTPUT_QUIET TIMEOUT 10)

ggarra13/mrv2 cmake/build_python_windows.cmake :36 

execute_process(
    COMMAND ${CMD}
    WORKING_DIRECTORY ${ROOT_DIR}
    ERROR_VARIABLE BAT_CMD_ERROR
    OUTPUT_VARIABLE BAT_CMD_OUTPUT
    ECHO_ERROR_VARIABLE 
    ECHO_OUTPUT_VARIABLE 
    COMMAND_ERROR_IS_FATAL ANY
)

Slicer/SlicerGitSVNArchive CMake/SlicerFunctionToday.cmake :13 

execute_process(COMMAND cmd /c "date /T"
                    ERROR_VARIABLE getdate_error
                    RESULT_VARIABLE getdate_result
                    OUTPUT_VARIABLE today_date
                    OUTPUT_STRIP_TRAILING_WHITESPACE)

beyond-all-reason/RecoilEngine rts/build/cmake/TestCXXFlags.cmake :108 

execute_process(COMMAND ${CMAKE_LINKER} "-v"
		OUTPUT_VARIABLE linkerVersion
		ERROR_VARIABLE linkerVersion
	)

HumbleNet/HumbleNet 3rdparty/libwebsockets/cmake/FindGit.cmake :121 

execute_process(COMMAND ${GIT_EXECUTABLE} svn info
        WORKING_DIRECTORY ${dir}
        TIMEOUT 3
        ERROR_VARIABLE git_svn_info_error
        OUTPUT_VARIABLE ${prefix}_WC_INFO
        RESULT_VARIABLE git_svn_info_result
        OUTPUT_STRIP_TRAILING_WHITESPACE)

cvet/fonline ThirdParty/mongo-c-driver/build/cmake/TestProject.cmake :207 

execute_process(
        COMMAND_ECHO STDERR
        WORKING_DIRECTORY "${bin_dir}"
        RESULT_VARIABLE retc
        OUTPUT_VARIABLE output
        ERROR_VARIABLE output
        ECHO_OUTPUT_VARIABLE
        ECHO_ERROR_VARIABLE
        COMMAND ${CMAKE_COMMAND}
            -S "${src_dir}"
            -B "${bin_dir}"
            -G "${TEST_PROJECT_GENERATOR}"
            -D "CMAKE_BUILD_TYPE=${TEST_PROJECT_BUILD_TYPE}"
            --no-warn-unused-cli
            --log-context
            --log-level=debug
            ${fwd_settings}
            ${TEST_PROJECT_CONFIGURE_ARGS}
    )

nsimplex/ktools cmake/thirdparty/CheckMicCXXCompilerFlag.cmake :51 

execute_process(
         COMMAND "${MIC_CXX}" -mmic -c -o "${_tmpdir}/src.o"
         "${_FLAG}" "${_tmpdir}/src.cpp"
         WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
         RESULT_VARIABLE ${_RESULT}
         OUTPUT_VARIABLE OUTPUT
         ERROR_VARIABLE OUTPUT
         )

casacore/casacore cmake/FindNUMPY.cmake :53 

execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c"
"import numpy as n; print(n.__version__); print(n.get_include());"
RESULT_VARIABLE _NUMPY_SEARCH_SUCCESS
OUTPUT_VARIABLE _NUMPY_VALUES_OUTPUT
ERROR_VARIABLE _NUMPY_ERROR_VALUE
OUTPUT_STRIP_TRAILING_WHITESPACE)