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

nCine/nCine cmake/ncine_get_version.cmake :3 

execute_process(
		COMMAND ${GIT_EXECUTABLE} rev-list --count HEAD
		WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
		RESULT_VARIABLE GIT_FAIL
		OUTPUT_VARIABLE GIT_REV_COUNT
		ERROR_QUIET
		OUTPUT_STRIP_TRAILING_WHITESPACE
	)

timi-liuliang/echo thirdparty/eigen-3.3.3/cmake/FindComputeCpp.cmake :131 

execute_process(COMMAND ${COMPUTECPP_INFO_TOOL} "--dump-device-compiler-flags"
  OUTPUT_VARIABLE COMPUTECPP_DEVICE_COMPILER_FLAGS
  RESULT_VARIABLE COMPUTECPP_INFO_TOOL_RESULT OUTPUT_STRIP_TRAILING_WHITESPACE)

etorth/mir2x cmake/deps/BuildLibpinyin.cmake :20 

EXECUTE_PROCESS(
        COMMAND ${libdb_SOURCE_DIR}/dist/configure --prefix=${MIR2X_3RD_PARTY_DIR}/libdb/build --enable-shared=no
        WORKING_DIRECTORY ${libdb_BINARY_DIR}

        RESULT_VARIABLE libdb_CONFIGURED

        OUTPUT_QUIET
        COMMAND_ERROR_IS_FATAL ANY
    )

geodynamics/aspect CMakeLists.txt :1001 

execute_process(
    COMMAND ${CMAKE_COMMAND} -G "${ASPECT_TEST_GENERATOR}"
        -D ASPECT_RUN_ALL_TESTS=${ASPECT_RUN_ALL_TESTS}
        -D ASPECT_COMPARE_TEST_RESULTS=${ASPECT_COMPARE_TEST_RESULTS}
        -D Aspect_DIR=${CMAKE_BINARY_DIR}
        -D CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
        -D ASPECT_BINARY=${CMAKE_BINARY_DIR}/aspect
        ${CMAKE_CURRENT_SOURCE_DIR}/tests
    OUTPUT_FILE setup_tests.log
    RESULT_VARIABLE test_cmake_result
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/tests
   )

AtomicGameEngine/AtomicGameEngine Build/CMake/Modules/GetGitRevisionDescription.cmake :107 

execute_process(COMMAND
        "${GIT_EXECUTABLE}"
        describe
        ${hash}
        ${ARGN}
        WORKING_DIRECTORY
        "${CMAKE_CURRENT_SOURCE_DIR}"
        RESULT_VARIABLE
        res
        OUTPUT_VARIABLE
        out
        ERROR_QUIET
        OUTPUT_STRIP_TRAILING_WHITESPACE)

u3d-community/U3D cmake/Modules/CheckCompilerToolchain.cmake :194 

execute_process (COMMAND ${CMAKE_C_COMPILER} ${ARCH_FLAGS} -E -dM -xc ${NULL_DEVICE${EMCC_FIX}} RESULT_VARIABLE CC_EXIT_STATUS OUTPUT_VARIABLE NATIVE_PREDEFINED_MACROS ERROR_QUIET)

oceancx/CXEngine cmake/cotire.cmake :1985 

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

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
        )

FreeCAD/FreeCAD cMake/FreeCadMacros.cmake :313 

execute_process(
			COMMAND ${Python3_EXECUTABLE} -m pip show ${PACKAGE}
			RESULT_VARIABLE FAILURE
			OUTPUT_VARIABLE PRINT_OUTPUT
	)

godlikepanos/anki-3d-engine ThirdParty/Sdl2/CMakeLists.txt :2647 

execute_process(COMMAND
    "${GIT_EXECUTABLE}" remote get-url origin
    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
    RESULT_VARIABLE GIT_URL_STATUS
    OUTPUT_VARIABLE GIT_URL
    ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)

PacktPublishing/3D-Graphics-Rendering-Cookbook CMakeLists.txt :17 

execute_process(
		COMMAND ${PYTHON_EXECUTABLE} "bootstrap.py"
		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
		RESULT_VARIABLE bootstrap_result
	)

prusa3d/Prusa-Firmware cmake/AnyAvrGcc.cmake :32 

execute_process(
    COMMAND ${UTIL_SEARCH_CMD} ${TOOLCHAIN_PREFIX}gcc
    OUTPUT_VARIABLE AVR_GCC_PATH
    OUTPUT_STRIP_TRAILING_WHITESPACE
    RESULT_VARIABLE FIND_RESULT
    )

SoftFever/OrcaSlicer cmake/modules/OpenVDBUtils.cmake :145 

execute_process(COMMAND ${OPENVDB_PRINT} "--version"
      RESULT_VARIABLE _VDB_PRINT_RETURN_STATUS
      OUTPUT_VARIABLE _VDB_PRINT_VERSION_STRING
      OUTPUT_STRIP_TRAILING_WHITESPACE
    )

anhttran/3dmm_basic lib/3rdParty/Eigen/cmake/language_support.cmake :45 

execute_process (
      COMMAND ${CMAKE_COMMAND} . -G "${CMAKE_GENERATOR}"
      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/language_tests/${language}
      RESULT_VARIABLE return_code
      OUTPUT_QUIET
      ERROR_QUIET
      )

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

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

Hork-Engine/Hork-Source ThirdParty/SDL3/cmake/android/SdlAndroidScript.cmake :60 

execute_process(
      COMMAND ${CMAKE_COMMAND} --build "${BUILD_FOLDER}" --target ${install_targets}
      RESULT_VARIABLE res
  )

STORM-IRIT/Radium-Engine doc/CMakeLists.txt :52 

execute_process(
                COMMAND ${GIT_EXECUTABLE} submodule update --init ${RADIUM_DOXYGEN_AWESOME_CSS_ROOT}
                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} RESULT_VARIABLE GIT_SUBMOD_RESULT
            )

RavEngine/RavEngine deps/harfbuzz/CMakeLists.txt :395 

execute_process(COMMAND "${Python3_EXECUTABLE}" "${GLIB_MKENUMS}" --version
      RESULT_VARIABLE GLIB_MKENUMS_PYTHON
      OUTPUT_QUIET ERROR_QUIET
    )

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)

zenustech/zeno projects/.unusedTools/cmake/OpenVDBUtils.cmake :114 

execute_process(COMMAND ${OPENVDB_PRINT} "--version"
      RESULT_VARIABLE _VDB_PRINT_RETURN_STATUS
      OUTPUT_VARIABLE _VDB_PRINT_VERSION_STRING
      ERROR_QUIET
      OUTPUT_STRIP_TRAILING_WHITESPACE
    )

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
    )

ElyPrismLauncher/ElyPrismLauncher cmake/GitFunctions.cmake :16 

execute_process(COMMAND ${GIT_EXECUTABLE} ${GIT_RUN_COMMAND}
        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
        RESULT_VARIABLE GIT_RESULTVAR
        OUTPUT_VARIABLE GIT_OUTVAR
        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
		)

etternagame/etterna CMake/Helpers/SetupGit.cmake :2 

execute_process(COMMAND git describe --tags
  WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
  OUTPUT_VARIABLE PRODUCT_GIT_HASH
  RESULT_VARIABLE ret
  OUTPUT_STRIP_TRAILING_WHITESPACE
)

NREL/OpenStudio ruby/test/CMakeLists.txt :39 

execute_process (COMMAND "${SYSTEM_RUBY_EXECUTABLE}" -e "puts RUBY_VERSION"
      RESULT_VARIABLE _result
      OUTPUT_VARIABLE _system_ruby_version
      ERROR_QUIET
      OUTPUT_STRIP_TRAILING_WHITESPACE)

OpenChemistry/avogadroapp cmake/DetermineVersion.cmake :25 

execute_process(
      COMMAND ${git_command} describe
      WORKING_DIRECTORY ${source_dir}
      RESULT_VARIABLE result
      OUTPUT_VARIABLE output
      ERROR_QUIET
      OUTPUT_STRIP_TRAILING_WHITESPACE
      ERROR_STRIP_TRAILING_WHITESPACE)

KDE/digikam project/bundles/3rdparty/CMakeLists.txt :55 

execute_process(COMMAND
                        wget -q -O - -o /dev/null http://download.kde.org/stable/applications/${version}/src/${name}-${version}.tar.xz.mirrorlist
                        COMMAND
                        grep "MD5 Hash"
                        COMMAND
                        grep -o -P "(?<=<tt>).*(?=</tt>)"
                        RESULT_VARIABLE
                        wgetresult
                        OUTPUT_VARIABLE
                        md5sm
                        OUTPUT_STRIP_TRAILING_WHITESPACE
        )

Morwenn/cpp-sort cmake/DownloadProject.cmake :173 

execute_process(COMMAND ${CMAKE_COMMAND} --build .
                    RESULT_VARIABLE result
                    ${OUTPUT_QUIET}
                    WORKING_DIRECTORY "${DL_ARGS_DOWNLOAD_DIR}"
    )

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)

RSIA-LIESMARS-WHU/LSHBOX include/eigen/cmake/language_support.cmake :45 

execute_process (
      COMMAND ${CMAKE_COMMAND} .
      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/language_tests/${language}
      RESULT_VARIABLE return_code
      OUTPUT_QUIET
      ERROR_QUIET
      )

liminchen/OptCuts ext/libigl/external/cgal/src/CGAL_Project/cmake/modules/CGAL_Macros.cmake :130 

execute_process(COMMAND "${CMAKE_CXX_COMPILER}" -print-search-dirs
              RESULT_VARIABLE ok
              OUTPUT_VARIABLE out_search_dirs
              TIMEOUT 5)

KhronosGroup/Vulkan-Samples bldsys/cmake/android_sync_folder.cmake :43 

execute_process(
  COMMAND
  ${ADB_COMMAND}
  RESULT_VARIABLE
  ret_var
  OUTPUT_VARIABLE
  ret_msg
  OUTPUT_STRIP_TRAILING_WHITESPACE)

SCOREC/core cdash/nightly.cmake :72 

execute_process(COMMAND "${CTEST_GIT_COMMAND}" clone ${MESH_URL_BASE}.git meshes
        WORKING_DIRECTORY "${MESHES}"
        RESULT_VARIABLE RETVAR)

bareos/bareos cmake/BareosCheckChflags.cmake :27 

execute_process(
    COMMAND ${CHFLAGS_PROG} nosunlink chflags-test-file.txt
    WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
    RESULT_VARIABLE CHFLAGS_RETURN
  )

maidsafe-archive/MaidSafe cmake_modules/build_cbfs.cmake :184 

execute_process(COMMAND msbuild /M:7 /P:Configuration=Debug,Platform=Win32 CbFS_VS2013.sln
                WORKING_DIRECTORY "${CbfsRootDir}/SourceCode/CBFS/CPP"
                RESULT_VARIABLE ResVar OUTPUT_VARIABLE OutVar)

MultiMC/Launcher cmake/GetGitRevisionDescription.cmake :107 

execute_process(COMMAND
        "${GIT_EXECUTABLE}"
        describe
        ${hash}
        ${ARGN}
        WORKING_DIRECTORY
        "${CMAKE_CURRENT_SOURCE_DIR}"
        RESULT_VARIABLE
        res
        OUTPUT_VARIABLE
        out
        ERROR_QUIET
        OUTPUT_STRIP_TRAILING_WHITESPACE)

PolyMC/PolyMC cmake/GetGitRevisionDescription.cmake :269 

execute_process(
        COMMAND "${GIT_EXECUTABLE}" diff-index --quiet HEAD --
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        RESULT_VARIABLE res
        OUTPUT_VARIABLE out
        ERROR_QUIET OUTPUT_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/version.cmake :9 

execute_process(
                COMMAND ${GIT_EXECUTABLE} rev-parse --abbrev-ref HEAD
                WORKING_DIRECTORY ${REPO_ROOT}
                OUTPUT_VARIABLE GIT_BRANCH
                RESULT_VARIABLE EXIT_CODE
                OUTPUT_STRIP_TRAILING_WHITESPACE)

x64dbg/x64dbg cmake/cmkr.cmake :58 

execute_process(COMMAND ${ARGV} RESULT_VARIABLE CMKR_EXEC_RESULT)

gnss-sdr/gnss-sdr cmake/Modules/SetupPython.cmake :17 

execute_process(
        COMMAND ${PYTHON_EXECUTABLE} -c "
#########################################
try: import ${mod}
except:
    try: ${mod}
    except: exit(-1)
try: assert ${cmd}
except: exit(-1)
#########################################"
        OUTPUT_QUIET ERROR_QUIET
        RESULT_VARIABLE ${have}
    )

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

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

performous/performous cmake/Modules/GetGitRevisionDescription.cmake :203 

execute_process(
        COMMAND "${GIT_EXECUTABLE}" describe --tags --always ${hash} ${ARGN}
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        RESULT_VARIABLE res
        OUTPUT_VARIABLE out
        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)

CppMicroServices/CppMicroServices cmake/usCTestScript.cmake :48 

execute_process( COMMAND bash ${CTEST_SOURCE_DIRECTORY}/cmake/xcodebuild_pretty.sh ${CTEST_BINARY_DIRECTORY} ${CTEST_BUILD_CONFIGURATION}
                     RESULT_VARIABLE res )

SsageParuders/Android_Native_Surface my_android_opencv/cmake/OpenCVDetectCUDA.cmake :506 

execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CUDA_CUDA_LIBRARY}" "${CUDA_STUB_TARGET_PATH}/libcuda.so.1"
          RESULT_VARIABLE CUDA_STUB_COPY_RESULT)

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
      )

psi4/psi4 psi4/driver/p4util/CMakeLists.txt :19 

execute_process(COMMAND ${Python_EXECUTABLE} -c
        "from Cython.Build import cythonize; cythonize('${CMAKE_CURRENT_SOURCE_DIR}/${py}.py', language_level=3)"
        RESULT_VARIABLE _exec_python_err)

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)

moneymanagerex/moneymanagerex util/FindwxWidgets.cmake :696 

execute_process(
        COMMAND sh "${wxWidgets_CONFIG_EXECUTABLE}"
          ${wxWidgets_CONFIG_OPTIONS} --${_OPT_NAME}=yes
        RESULT_VARIABLE _wx_result_yes
        OUTPUT_QUIET
        ERROR_QUIET
        )

NVIDIA/MatX cmake/rapids-cmake/testing/cpm/cpm_find-patch-command-required/CMakeLists.txt :57 

execute_process(
    COMMAND ${GIT_EXECUTABLE} diff --quiet ${tag}
    RESULT_VARIABLE REPO_IS_PATCHED
    WORKING_DIRECTORY "${fmt_SOURCE_DIR}")

AcademySoftwareFoundation/MaterialX source/PyMaterialX/External/PyBind11/tools/pybind11Common.cmake :259 

execute_process(
      COMMAND
        ${${_Python}_EXECUTABLE} -c "
try:
    from importlib.metadata import version
except ImportError:
    from pkg_resources import get_distribution
    def version(s):
        return get_distribution(s).version
print(version('${PYPI_NAME}'))
        "
      RESULT_VARIABLE RESULT_PRESENT
      OUTPUT_VARIABLE PKG_VERSION
      ERROR_QUIET)

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)

NVIDIA/DALI cmake/CUDA_utils.cmake :92 

execute_process(COMMAND ${compiler} ${cudacc_command}
                  RESULT_VARIABLE tmp_out_status
                  OUTPUT_QUIET
                  ERROR_QUIET
                  )

LiangliangNan/MVStudio 3rd_party/clapack/TESTING/runtest.cmake :24 

execute_process(COMMAND "${TEST}" 
  ${ARGS}
  RESULT_VARIABLE RET)

OSVR/SteamVR-OSVR cmake/SteamVRPaths.cmake :103 

execute_process(COMMAND "${VRPATHREG}" show
		RESULT_VARIABLE _vrpathreg_result
		OUTPUT_VARIABLE _vrpathreg_output
		ERROR_QUIET
	)

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
    )

scanner-research/scanner cmake/Modules/FindDoxygen.cmake :389 

execute_process(
            COMMAND "${DOXYGEN_EXECUTABLE}" --version
            OUTPUT_VARIABLE DOXYGEN_VERSION
            OUTPUT_STRIP_TRAILING_WHITESPACE
            RESULT_VARIABLE _Doxygen_version_result
        )

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 ARCHIVE/CMAKE/External_Boost_buildboost.cmake :38 

execute_process(COMMAND ./b2 install --prefix=${BOOST_INSTALL_DIR}
    WORKING_DIRECTORY ${BUILD_DIR} RESULT_VARIABLE build_result)

Tulip-Dev/tulip cmake/GetGitRevisionDescription.cmake :152 

execute_process(COMMAND
		"${GIT_EXECUTABLE}"
		diff-index --quiet HEAD --
		WORKING_DIRECTORY
		"${CMAKE_CURRENT_SOURCE_DIR}"
		RESULT_VARIABLE
		res
		OUTPUT_VARIABLE
		out
		ERROR_QUIET
		OUTPUT_STRIP_TRAILING_WHITESPACE)

gismo/gismo cmake/gsFetch.cmake :62 

execute_process(COMMAND ${CMAKE_COMMAND} --build .
    OUTPUT_QUIET
    RESULT_VARIABLE result
    WORKING_DIRECTORY "${GF_DOWNLOAD_DIR}" )

awawa-dev/HyperHDR cmake/installers.cmake :51 

execute_process(
					COMMAND brew --prefix openssl@3
					RESULT_VARIABLE BREW_OPENSSL3
					OUTPUT_VARIABLE BREW_OPENSSL3_PATH
					OUTPUT_STRIP_TRAILING_WHITESPACE
				)

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/MacroUtilities.cmake :450 

execute_process(
            COMMAND ${GIT_EXECUTABLE} submodule update --init ${_RECURSE}
                    ${CHECKOUT_ADDITIONAL_CMDS} ${CHECKOUT_RELATIVE_PATH}
            WORKING_DIRECTORY ${CHECKOUT_WORKING_DIRECTORY}
            RESULT_VARIABLE RET)

emsec/hal deps/pybind11/tools/pybind11Common.cmake :237 

execute_process(
      COMMAND
        ${${_Python}_EXECUTABLE} -c
        "from pkg_resources import get_distribution; print(get_distribution('${PYPI_NAME}').version)"
      RESULT_VARIABLE RESULT_PRESENT
      OUTPUT_VARIABLE PKG_VERSION
      ERROR_QUIET)

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/CheckNasm.cmake :2 

execute_process(
    COMMAND which nasm
    RESULT_VARIABLE no_nasm
    OUTPUT_QUIET
    ERROR_QUIET)

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 cmake/OpenVDBHoudiniSetup.cmake :349 

execute_process(COMMAND echo "#include <string>"
    COMMAND ${CMAKE_CXX_COMPILER} "-x" "c++" "-E" "-dM" "-"
    COMMAND grep "-F" "_GLIBCXX_USE_CXX11_ABI"
    TIMEOUT 10
    RESULT_VARIABLE QUERIED_GCC_CXX11_ABI_SUCCESS
    OUTPUT_VARIABLE _GCC_CXX11_ABI)

OSGeo/PROJ test/CMakeLists.txt :17 

execute_process(
      COMMAND ${HAS_CURL} -I https://www.google.com
      OUTPUT_QUIET
      ERROR_QUIET
      RESULT_VARIABLE NO_CONNECTION
    )

apache/trafficserver lib/Catch2/extras/CatchAddTests.cmake :96 

execute_process(
      COMMAND ${_TEST_EXECUTOR} "${_TEST_EXECUTABLE}" ${spec} ${reporter_arg} --list-reporters
      OUTPUT_VARIABLE reporter_check_output
      RESULT_VARIABLE reporter_check_result
      WORKING_DIRECTORY "${_TEST_WORKING_DIR}"
    )

SergiusTheBest/plog samples/CMakeLists.txt :15 

execute_process(
        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/CMakeFiles
        COMMAND ${CMAKE_CXX_COMPILER} dummy.mm
        RESULT_VARIABLE result
        ERROR_QUIET
        OUTPUT_QUIET
    )

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
    )

dartsim/dart CMakeLists.txt :220 

execute_process(COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/scripts/case_sensitive_filesystem
                RESULT_VARIABLE FILESYSTEM_CASE_SENSITIVE_RETURN)

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
      )

univrsal/input-overlay cmake/macos/buildspec.cmake :25 

execute_process(COMMAND "xattr" -r -d com.apple.quarantine "${dependencies_dir}"
                  RESULT_VARIABLE result COMMAND_ERROR_IS_FATAL ANY)

YosysHQ/nextpnr 3rdparty/pybind11/tools/pybind11Common.cmake :223 

execute_process(
      COMMAND
        ${${_Python}_EXECUTABLE} -c "
try:
    from importlib.metadata import version
except ImportError:
    from pkg_resources import get_distribution
    def version(s):
        return get_distribution(s).version
print(version('${PYPI_NAME}'))
        "
      RESULT_VARIABLE RESULT_PRESENT
      OUTPUT_VARIABLE PKG_VERSION
      ERROR_QUIET)

steemit/steem libraries/fc/GitVersionGen/GetGitRevisionDescription.cmake :151 

execute_process(COMMAND
		"${GIT_EXECUTABLE}"
		"show"
                "-s"
                "--format=%ct"
		${hash}
		${ARGN}
		WORKING_DIRECTORY
		"${CMAKE_CURRENT_SOURCE_DIR}"
		RESULT_VARIABLE
		res
		OUTPUT_VARIABLE
		out
		ERROR_QUIET
		OUTPUT_STRIP_TRAILING_WHITESPACE)

brndnmtthws/conky cmake/CatchAddTests.cmake :102 

execute_process(
      COMMAND ${_TEST_EXECUTOR} "${_TEST_EXECUTABLE}" ${spec} ${reporter_arg}
              --list-reporters
      OUTPUT_VARIABLE reporter_check_output
      RESULT_VARIABLE reporter_check_result
      WORKING_DIRECTORY "${_TEST_WORKING_DIR}")

root-project/root cmake/modules/FindDask.cmake :20 

execute_process(
    COMMAND ${Python3_EXECUTABLE} -c "import distributed; import dask; print(dask.__version__)"
    RESULT_VARIABLE _DASK_IMPORT_EXIT_STATUS
    OUTPUT_VARIABLE _DASK_VALUES_OUTPUT
    ERROR_VARIABLE _DASK_ERROR_VALUE
    OUTPUT_STRIP_TRAILING_WHITESPACE
)

brainflow-dev/brainflow third_party/fmt/test/compile-error-test/CMakeLists.txt :92 

execute_process(
      COMMAND
        "${CMAKE_COMMAND}" --build "${build_directory}" --target "test-${test_name}"
      WORKING_DIRECTORY "${build_directory}"
      RESULT_VARIABLE result_var
      OUTPUT_VARIABLE output_var
      ERROR_QUIET)

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
)

facebookincubator/velox CMakeLists.txt :667 

execute_process(
    COMMAND brew --prefix flex
    RESULT_VARIABLE BREW_FLEX
    OUTPUT_VARIABLE BREW_FLEX_PREFIX
    OUTPUT_STRIP_TRAILING_WHITESPACE
  )

Slicer/Slicer CMake/CTestPackage.cmake :43 

execute_process(
      COMMAND ${CMAKE_COMMAND} --build ${MY_BINARY_DIR} --target package --config ${MY_CONFIG}
      WORKING_DIRECTORY ${MY_BINARY_DIR}
      OUTPUT_STRIP_TRAILING_WHITESPACE
      OUTPUT_FILE ${cpack_output_file}
      RESULT_VARIABLE rv
      )

edubart/otclient src/framework/cmake/cotire.cmake :1242 

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

Oneflow-Inc/oneflow cmake/python.cmake :2 

execute_process(
    COMMAND which python3
    RESULT_VARIABLE STATUS
    OUTPUT_VARIABLE OUTPUT
    ERROR_QUIET)

projectM-visualizer/projectm cmake/FindSphinx.cmake :69 

execute_process(
      COMMAND ${SPHINX_PYTHON_EXECUTABLE} -c "import ${_ext}"
      RESULT_VARIABLE _result)

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 CMakeLists.txt :29 

EXECUTE_PROCESS(COMMAND wmic os get version
    OUTPUT_VARIABLE NT_RELEASE_VERSION
    OUTPUT_STRIP_TRAILING_WHITESPACE
    RESULT_VARIABLE WMIC_RESULT
    )

NREL/EnergyPlus cmake/RunSimulation.cmake :228 

execute_process(
    COMMAND ${ECHO_CMD}
    COMMAND "${ENERGYPLUS_EXE}" -w "${EPW_PATH}" -d "${OUTPUT_DIR_PATH}" ${ENERGYPLUS_FLAGS_LIST} "${IDF_PATH}"
    WORKING_DIRECTORY "${OUTPUT_DIR_PATH}"
    RESULT_VARIABLE RESULT)

csmith-project/creduce creduce/CMakeLists.txt :78 

execute_process(COMMAND ${PERL_EXECUTABLE} -MRegexp::Common -e ""
  ERROR_QUIET
  RESULT_VARIABLE status
  )

Devsh-Graphics-Programming/Nabla 3rdparty/dxc/CMakeLists.txt :101 

execute_process(COMMAND "${CMAKE_COMMAND}" -C "${CMAKE_CURRENT_SOURCE_DIR}/dxc/cmake/caches/PredefinedParams.cmake" -S "${CMAKE_CURRENT_SOURCE_DIR}/dxc" -B "${DXC_BUILD_DIR}" -G "${CMAKE_GENERATOR}" ${NBL_DXC_CMAKE_OPTIONS}
	RESULT_VARIABLE DXC_CMAKE_RESULT
	OUTPUT_VARIABLE DXC_CMAKE_STREAM_PIPE
)

mysql/mysql-server CMakeLists.txt :29 

EXECUTE_PROCESS(COMMAND wmic os get version
    OUTPUT_VARIABLE NT_RELEASE_VERSION
    OUTPUT_STRIP_TRAILING_WHITESPACE
    RESULT_VARIABLE WMIC_RESULT
    )

robotology/yarp bindings/ruby/CMakeLists.txt :24 

execute_process(
    COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['${RBVAR}']"
    RESULT_VARIABLE _RUBY_SUCCESS
    OUTPUT_VARIABLE _RUBY_OUTPUT
    ERROR_QUIET)

mysql/mysql-router cmake/configure.cmake :220 

EXECUTE_PROCESS(
      COMMAND sh -c "elfdump ${real_library} | grep SONAME"
      RESULT_VARIABLE result
      OUTPUT_VARIABLE sonameline
    )