cmake add_custom_command examples

Signatures

add_custom_command(OUTPUT output1 [output2 ...]
  COMMAND command1 [ARGS] [args1...]
  [COMMAND command2 [ARGS] [args2...] ...]
  [MAIN_DEPENDENCY depend]
  [DEPENDS [depends...]]
  [BYPRODUCTS [files...]]
  [IMPLICIT_DEPENDS <lang1> depend1
  [<lang2> depend2] ...]
  [WORKING_DIRECTORY dir]
  [COMMENT comment]
  [DEPFILE depfile]
  [JOB_POOL job_pool]
  [JOB_SERVER_AWARE <bool>]
  [VERBATIM] [APPEND] [USES_TERMINAL]
  [COMMAND_EXPAND_LISTS]
[DEPENDS_EXPLICIT_ONLY])

Examples

u3d-community/U3D Source/ThirdParty/LuaJIT/src/host/CMakeLists.txt :69 

add_custom_command (OUTPUT ${GEN_ARCH_H}
    COMMAND minilua ${DASM} ${DASM_FLAGS} -o ${GEN_ARCH_H} ${DASM_DASC}
    DEPENDS minilua ${DASM_LUA} ${DASM_DASC}
    WORKING_DIRECTORY ${DASM_DIR}
    COMMENT "Generating buildvm arch header file")

PieKing1215/FallingSandSurvival CMake/Utils.cmake :169 

add_custom_command(
                TARGET ${TARGET}
                ${STEP}
                ${COMMANDS}
                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
                COMMENT ${COMMENT})

mgerhardy/caveexpress cmake/macros.cmake :284 

add_custom_command(TARGET ${PROJECTNAME} POST_BUILD COMMAND ${ANDROID_ANT} ${ANT_FLAGS} ${ANT_TARGET} WORKING_DIRECTORY ${ANDROID_BIN_ROOT})

oceancx/CXEngine cmake/cotire.cmake :2528 

add_custom_command(
		OUTPUT "${_joinedFile}"
		COMMAND ${_prefixCmd}
		DEPENDS ${_files}
		COMMENT "${_comment}"
		WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
		VERBATIM)

f3d-app/f3d python/CMakeLists.txt :100 

add_custom_command(
    TARGET pyf3d
    POST_BUILD
    COMMAND python ${CMAKE_CURRENT_SOURCE_DIR}/generate_stubs.py --into=${f3d_binary_dir}
    WORKING_DIRECTORY ${f3d_binary_dir})

o3de/o3de Code/LauncherUnified/Platform/iOS/launcher_project_ios.cmake :41 

add_custom_command(TARGET ${project_name}.GameLauncher POST_BUILD
    COMMAND ${LY_PYTHON_CMD} layout_tool.py
        -p iOS
        -a ${LY_ASSET_DEPLOY_ASSET_TYPE}
        --project-path ${project_real_path}
        -m ${LY_ASSET_DEPLOY_MODE}
        --create-layout-root
        -l $<TARGET_BUNDLE_DIR:${project_name}.GameLauncher>/assets
        --build-config $<CONFIG>
        --warn-on-missing-assets
        --verify
        --copy
        --override-pak-folder ${project_real_path}/AssetBundling/Bundles
        ${LY_OVERRIDE_PAK_ARGUMENT}
    WORKING_DIRECTORY ${layout_tool_dir}
    COMMENT "Synchronizing Layout Assets ..."
    VERBATIM
)

prusa3d/PrusaSlicer src/CMakeLists.txt :262 

add_custom_command(TARGET PrusaSlicer POST_BUILD
            COMMAND ln -sf PrusaSlicer prusa-slicer
            COMMAND ln -sf PrusaSlicer prusa-gcodeviewer
            COMMAND ln -sf PrusaSlicer PrusaGCodeViewer
            WORKING_DIRECTORY "$<TARGET_FILE_DIR:PrusaSlicer>"
            COMMENT "Symlinking the G-code viewer to PrusaSlicer, symlinking to prusa-slicer and prusa-gcodeviewer"
            VERBATIM)

FreeCAD/FreeCAD cMake/FreeCadMacros.cmake :204 

add_custom_command(
		 		OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${OUTPUT_FILE}"
		 		COMMAND "${Python3_EXECUTABLE}" "${TOOL_NATIVE_PATH}" "${SOURCE_NATIVE_PATH}" "${OUTPUT_FILE}" "${VARIABLE}"
				MAIN_DEPENDENCY "${CMAKE_CURRENT_SOURCE_DIR}/${INPUT_FILE}"
				DEPENDS "${TOOL_PATH}"
				WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
				COMMENT "Building files out of ${INPUT_FILE}")

OGRECave/ogre Components/Csharp/CMakeLists.txt :89 

add_custom_command(TARGET libOgre POST_BUILD
    COMMAND "${CMAKE_CSharp_COMPILER}" -target:library -out:Ogre.dll "${PROJECT_BINARY_DIR}/csharp/*.cs"
    WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/csharp/")

godlikepanos/anki-3d-engine ThirdParty/Sdl3/examples/CMakeLists.txt :83 

add_custom_command(TARGET ${TARGET} POST_BUILD
                COMMAND ${CMAKE_COMMAND} ARGS -E make_directory $<TARGET_FILE_DIR:${TARGET}>/sdl-${TARGET}
                COMMAND ${CMAKE_COMMAND} ARGS -E copy_if_different ${AST_DATAFILES} $<TARGET_FILE_DIR:${TARGET}>/sdl-${TARGET}
                WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
            )

prusa3d/Prusa-Firmware lib/Catch2/CMake/FindGcov.cmake :142 

add_custom_command(OUTPUT ${TDIR}/${FILE}.gcov
			COMMAND ${GCOV_ENV} ${GCOV_BIN} ${TDIR}/${FILE}.gcno > /dev/null
			DEPENDS ${TNAME} ${TDIR}/${FILE}.gcno
			WORKING_DIRECTORY ${FILE_PATH}
		)

harfang3d/harfang3d doc/CMakeLists.txt :3 

add_custom_command(
 	OUTPUT
 		${CMAKE_CURRENT_BINARY_DIR}/harfang/api.xml
 	COMMAND
 		${Python3_EXECUTABLE} bind.py ${CMAKE_SOURCE_DIR}/binding/bind_harfang.py --xml --out ${CMAKE_CURRENT_BINARY_DIR}/harfang ${HG_BINDING_DEFINES}
 	MAIN_DEPENDENCY
 		${CMAKE_SOURCE_DIR}/binding/bind_harfang.py
 	WORKING_DIRECTORY
 		${HG_FABGEN_PATH}
 	COMMENT
 		"Generating Harfang API description file")

cadaver/turso3d ThirdParty/SDL/cmake/android/SdlAndroidFunctions.cmake :212 

add_custom_command(OUTPUT "${apk_file}"
    ${commands}
    DEPENDS ${arg_NATIVE_LIBS} ${depends} "$<TARGET_PROPERTY:${arg_APK_IN},OUTPUT>"
    WORKING_DIRECTORY "${workdir}"
  )

Hork-Engine/Hork-Source ThirdParty/SDL3/cmake/android/SdlAndroidFunctions.cmake :212 

add_custom_command(OUTPUT "${apk_file}"
    ${commands}
    DEPENDS ${arg_NATIVE_LIBS} ${depends} "$<TARGET_PROPERTY:${arg_APK_IN},OUTPUT>"
    WORKING_DIRECTORY "${workdir}"
  )

RavEngine/RavEngine deps/assimp/cmake-modules/DebSourcePPA.cmake :342 

add_custom_command(OUTPUT "${SOURCE_CHANGES_FILE}" COMMAND ${DEBUILD_EXECUTABLE} -S ${DEBUILD_OPTIONS} WORKING_DIRECTORY ${DEBIAN_SOURCE_DIR})

stuntrally/stuntrally cmake/Macros.cmake :37 

add_custom_command(
                OUTPUT ${ZIP_NAME}
                DEPENDS ${ZIP_FILES_DEP}
                COMMAND ${CMAKE_COMMAND} -E tar c ${ZIP_NAME} --format=zip --files-from="${TMP_FILE_DIR}/${ZIP_DIR}-filelist.txt"
                WORKING_DIRECTORY "${in_dir}/${ZIP_DIR}"
        )

nextcloud/desktop src/libsync/vfs/cfapi/shellext/CMakeLists.txt :49 

add_custom_command(
  OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${CFAPI_SHELL_EXTENSIONS_LIB_NAME}.rc"
  COMMAND ${CMAKE_COMMAND}
  ARGS -E copy "${CMAKE_CURRENT_BINARY_DIR}/${CFAPI_SHELL_EXTENSIONS_LIB_NAME}.rc.in" "${CMAKE_CURRENT_BINARY_DIR}/${CFAPI_SHELL_EXTENSIONS_LIB_NAME}.rc"
  DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${CUSTOM_STATE_ICON_LOCKED_NAME}.ico" "${CMAKE_CURRENT_BINARY_DIR}/${CUSTOM_STATE_ICON_SHARED_NAME}.ico"
  WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
)

AcademySoftwareFoundation/OpenShadingLanguage src/cmake/cuda_macros.cmake :158 

add_custom_command (OUTPUT ${bc_cuda}
        COMMAND ${LLVM_BC_GENERATOR}
            "-I${OPTIX_INCLUDES}"
            "-I${CUDA_INCLUDES}"
            "-I${CMAKE_CURRENT_SOURCE_DIR}"
            "-I${CMAKE_SOURCE_DIR}/src/liboslexec"
            "-I${CMAKE_BINARY_DIR}/include"
            "-I${PROJECT_SOURCE_DIR}/src/include"
            "-I${PROJECT_SOURCE_DIR}/src/cuda_common"
            ${ALL_OpenImageIO_INCLUDES}
            ${ALL_IMATH_INCLUDES}
            ${ALL_OPENEXR_INCLUDES}
            ${LLVM_COMPILE_FLAGS} ${CUDA_LIB_FLAGS} ${CLANG_MSVC_FIX} ${CUDA_TEXREF_FIX}
            -D__CUDACC__ -DOSL_COMPILING_TO_BITCODE=1 -DNDEBUG -DOIIO_NO_SSE -D__CUDADEVRT_INTERNAL__
            --language=cuda --cuda-device-only --cuda-gpu-arch=${CUDA_TARGET_ARCH}
            -Wno-deprecated-register -Wno-format-security
            -fno-math-errno -ffast-math ${CUDA_OPT_FLAG_CLANG} ${CLANG_FTZ_FLAG} -S -emit-llvm ${extra_clang_args}
            ${src} -o ${asm_cuda}
        COMMAND ${LLVM_AS_TOOL} -f -o ${bc_cuda} ${asm_cuda}
        DEPENDS ${exec_headers} ${PROJECT_PUBLIC_HEADERS} ${src}
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" )

etternagame/etterna extern/rapidjson/doc/CMakeLists.txt :15 

add_custom_command(OUTPUT html
        COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
        COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile.zh-cn
        COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/html
        DEPENDS ${MARKDOWN_DOC} ${SOURCES} ${DOXYFILES}
        WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/../
        )

NREL/OpenStudio pat/CMakeLists.txt :23 

add_custom_command(OUTPUT "${PAT_PRODUCT_FILE}"
    COMMAND cmd /C "${CMAKE_CURRENT_BINARY_DIR}/BuildPat.bat"
    DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/OpenStudio-PAT-${PAT_SHA}.zip"
    WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
  )

KDE/digikam project/bundles/appimage/icon-rcc/CMakeLists.txt :19 

add_custom_command(OUTPUT breeze.rcc
    COMMAND ${QT_RCC_EXECUTABLE} -project -o icons.qrc
    COMMAND $<TARGET_FILE_DIR:qrcAlias>/$<TARGET_FILE_NAME:qrcAlias> -i icons.qrc -o aliased.qrc
    COMMAND ${QT_RCC_EXECUTABLE} -binary -o ${CMAKE_BINARY_DIR}/breeze.rcc -root /icons/breeze aliased.qrc

    WORKING_DIRECTORY ${CMAKE_INSTALL_PREFIX}/share/icons/breeze
    DEPENDS qrcAlias
)

Kitware/kwiver CMake/utils/kwiver-utils-tests-python.cmake :157 

add_custom_command(
      TARGET  test-python-${name}
      COMMAND ${kwiver_test_environment}
              pytest ${path}.py
              "${kwiver_test_output_path}"
              ${ARGN}
      WORKING_DIRECTORY
              "${kwiver_test_working_path}"
      COMMENT "Running test \"${name}\"")

kahypar/mt-kahypar cmake/modules/gmock.cmake :18 

add_custom_command(TARGET ${target}
                       POST_BUILD
                       COMMAND rm -f ${target}_failed
                       WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
                       COMMENT "Running ${target}" VERBATIM)

KhronosGroup/Vulkan-Samples bldsys/cmake/android_package.cmake :83 

add_custom_command(
        OUTPUT
            bld.gradle.stamp
        DEPENDS
            gen.gradle.stamp
        COMMAND
            ${GRADLE_EXECUTABLE} assemble --no-daemon
        COMMAND
            ${CMAKE_COMMAND} -E touch bld.gradle.stamp
        COMMENT
            "Build android gradle project"
        WORKING_DIRECTORY
            ${TARGET_NAME}
        VERBATIM)

nv-legate/legate src/cmake/Modules/generate_fatbin_modules.cmake :112 

add_custom_command(OUTPUT "${fatbin_cc}"
                       COMMAND ${CMAKE_COMMAND} "-DVAR_NAME=${fatbin_var_name}"
                               "-DIN_FILE=$<TARGET_OBJECTS:${fatbin_target_name}>"
                               "-DOUT_CC_FILE=${fatbin_cc}" "-DOUT_H_FILE=${fatbin_h}"
                               "-DLEGATE_CMAKE_DIR=${LEGATE_CMAKE_DIR}" -P
                               "${LEGATE_CMAKE_DIR}/scripts/bin2c.cmake"
                       VERBATIM
                       WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
                       DEPENDS "${fatbin_target_name}"
                       COMMENT "Embedding binary objects $<TARGET_OBJECTS:${fatbin_target_name}> -> ${fatbin_cc}"
    )

Patoke/re-plants-vs-zombies CMake/Utils.cmake :155 

add_custom_command(OUTPUT ${OUTPUT}
                           ${COMMANDS}
                           DEPENDS ${DEPENDS}
                           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
                           COMMENT ${COMMENT})

MultiMC/Launcher cmake/UseJava.cmake :308 

add_custom_command(
            # NOTE: this command generates an artificial dependency file
            OUTPUT ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
            COMMAND ${Java_JAVAC_EXECUTABLE}
                ${CMAKE_JAVA_COMPILE_FLAGS}
                -classpath "${CMAKE_JAVA_INCLUDE_PATH_FINAL}"
                -d ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
                ${_JAVA_COMPILE_FILES}
            COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
            DEPENDS ${_JAVA_COMPILE_FILES}
            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
            COMMENT "Building Java objects for ${_TARGET_NAME}.jar"
        )

baidu/bigflow cmake/generic.cmake :204 

ADD_CUSTOM_COMMAND(TARGET ${TARGET_NAME} POST_BUILD
        COMMAND ${CMAKE_AR} cr ${outlibfile} *.o
        COMMAND ${CMAKE_RANLIB} ${outlibfile}
        WORKING_DIRECTORY ${lib}.objdir)

NVIDIA/nvshmem perftest/CMakeLists.txt :218 

add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${CUBIN_NAME}
                      COMMAND clang -c -emit-llvm -std=${BITCODE_CXX_STD} -x cuda --cuda-path=${CUDA_HOME} --cuda-device-only
                              --cuda-gpu-arch=${NVSHMEM_CLANG_ARCH} ${INCLUDE_DIRECTORIES} -DNVSHMEM_HOSTLIB_ONLY ${DIR_} -o ${NAME_}.bc.unoptimized
                      COMMAND llvm-link --only-needed ${NAME_}.bc.unoptimized ${BITCODE_LIB_PATH} -o ${NAME_}.bc.unoptimized.linked
                      COMMAND opt -O3 ${NAME_}.bc.unoptimized.linked -o ${NAME_}.bc
                      COMMAND llc -O3 --disable-tail-calls -mcpu=${NVSHMEM_CLANG_ARCH} -mattr=${NVSHMEM_PTX_ARCH} ${NAME_}.bc -o ${NAME_}.ptx
                      COMMAND ${CUDA_HOME}/bin/ptxas -c -arch=${NVSHMEM_CLANG_ARCH} ${NAME_}.ptx -o ${CUBIN_UNLINKED_NAME}
                      COMMAND ${CUDA_HOME}/bin/nvlink -arch=${NVSHMEM_CLANG_ARCH} ${CUBIN_UNLINKED_NAME} -o ${CUBIN_NAME}
                      COMMAND rm ${NAME_}.bc.unoptimized ${NAME_}.bc.unoptimized.linked  ${NAME_}.bc ${NAME_}.ptx ${CUBIN_UNLINKED_NAME}
                      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
                      DEPENDS nvshmem_perftest_helper libnvshmem_device_bitcode)

facebook/folly build/fbcode_builder/CMake/FBThriftCppLibrary.cmake :109 

add_custom_command(
    OUTPUT
      ${generated_headers}
      ${generated_sources}
    COMMAND_EXPAND_LISTS
    COMMAND
      "${CMAKE_COMMAND}" -E make_directory "${output_dir}"
    COMMAND
      "${FBTHRIFT_COMPILER}"
      --legacy-strict
      --gen "mstch_cpp2:${GEN_ARG_STR}"
      "${thrift_include_options}"
      -I "${FBTHRIFT_INCLUDE_DIR}"
      -o "${output_dir}"
      "${CMAKE_CURRENT_SOURCE_DIR}/${THRIFT_FILE}"
    WORKING_DIRECTORY
      "${CMAKE_BINARY_DIR}"
    MAIN_DEPENDENCY
      "${THRIFT_FILE}"
    DEPENDS
      ${ARG_DEPENDS}
      "${FBTHRIFT_COMPILER}"
  )

mariadb-corporation/MaxScale maxctrl/CMakeLists.txt :17 

add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/node_modules
      DEPENDS maxctrl_copy_sources package.json package-lock.json
      COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/npm_install.sh ${CMAKE_SOURCE_DIR}
      WORKING_DIRECTORY ${CMAKE_BINARY_DIR})

openvinotoolkit/openvino cmake/developer_package/cpplint/cpplint.cmake :66 

add_custom_command(
            OUTPUT
                "${output_file}"
            COMMAND
                "${CMAKE_COMMAND}"
                -D "Python3_EXECUTABLE=${Python3_EXECUTABLE}"
                -D "CPPLINT_SCRIPT=${OpenVINODeveloperScripts_DIR}/cpplint/cpplint.py"
                -D "INPUT_FILE=${source_file}"
                -D "OUTPUT_FILE=${output_file}"
                -D "WORKING_DIRECTORY=${CMAKE_CURRENT_SOURCE_DIR}"
                -D "SKIP_RETURN_CODE=${ENABLE_CPPLINT_REPORT}"
                -D "CUSTOM_FILTER=${custom_filter}"
                -P "${OpenVINODeveloperScripts_DIR}/cpplint/cpplint_run.cmake"
            DEPENDS
                "${source_file}"
                "${OpenVINODeveloperScripts_DIR}/cpplint/cpplint.py"
                "${OpenVINODeveloperScripts_DIR}/cpplint/cpplint_run.cmake"
            COMMENT
                "[cpplint] ${source_file_relative_root}"
            VERBATIM)

ezEngine/ezEngine Code/ThirdParty/LivePP/init.cmake :21 

add_custom_command(TARGET ${TARGET_NAME}
        COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different ${CMAKE_CURRENT_FUNCTION_LIST_DIR} $<TARGET_FILE_DIR:${TARGET_NAME}>/LivePP
        WORKING_DIRECTORY ${CMAKE_CURRENT_FUNCTION_LIST_DIR}
    )

CppMicroServices/CppMicroServices cmake/usFunctionEmbedResources.cmake :173 

add_custom_command(
        OUTPUT ${_source_output}
        COMMAND ${CMAKE_CXX_COMPILER} --std=c++17 ${_us_resource_cxx_flags} -c ${US_CMAKE_RESOURCE_DEPENDENCIES_CPP} -o stub.o
        COMMAND ${CMAKE_LINKER} -r -sectcreate __TEXT us_resources ${_zip_archive_name} stub.o -o ${_source_output}
        DEPENDS ${_zip_archive}
        WORKING_DIRECTORY ${_zip_archive_path}
        COMMENT "Linking resources zip file ${_zip_archive} for ${US_RESOURCE_TARGET}"
        VERBATIM
       )

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

add_custom_command(
        OUTPUT ${android_proj_target_files}
        COMMAND ${CMAKE_COMMAND} -E remove ${android_proj_target_files}
                                           "${android_proj_bin_dir}/bin/${ANDROID_MANIFEST_FILE}"  # avoid warning about sub-projects
        COMMAND ${ANDROID_EXECUTABLE} --silent update project --path "${android_proj_bin_dir}" --target "${android_proj_sdk_target}" --name "${target}"
        ${android_proj_lib_deps_commands}
        WORKING_DIRECTORY "${android_proj_bin_dir}"
        DEPENDS ${android_proj_file_deps}
        COMMENT "Updating Android project at ${path}. SDK target: ${android_proj_sdk_target}"
        )

moneymanagerex/moneymanagerex CMakeLists.txt :481 

add_custom_command(
        COMMAND ${CMAKE_COMMAND} -E tar "cf" "${output_file}" --format=zip -- ${input_files}
        WORKING_DIRECTORY "${working_dir}"
        OUTPUT  "${output_file}"
        DEPENDS ${input_files}
        COMMENT "Zipping to ${output_file}."
    )

chdb-io/chdb contrib/krb5-cmake/CMakeLists.txt :492 

add_custom_command(
    OUTPUT "${KRB5_ET_BIN_DIR}/error_map.h"
    COMMAND perl
    -I../../../util
    ../../../util/gen-map.pl
    -o${KRB5_ET_BIN_DIR}/error_map.h
    NAME=gsserrmap
    KEY=OM_uint32
    VALUE=char*
    COMPARE=compare_OM_uint32
    FREEVALUE=free_string
    WORKING_DIRECTORY "${KRB5_SOURCE_DIR}/lib/gssapi/krb5"
)

TheAssemblyArmada/Thyme cmake/modules/ClangFormat.cmake :27 

add_custom_command(
            TARGET format
            PRE_BUILD
            COMMAND ${CLANG_FORMAT_EXECUTABLE} -style=file -i --verbose \"${SOURCE_FILE}\"
            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})

sambayless/monosat CMakeLists.txt :476 

add_custom_command(TARGET libmonosat
            POST_BUILD
            COMMAND
            "${Java_JAR_EXECUTABLE}" "cfM" "${CMAKE_BINARY_DIR}/monosat_src.zip" ${RELATIVE_JAVA_PATHS}  "||" "true" # do not quote RELATIVE_JAVA_PATHS, or else semicolons will be injected between items.
            #OUTPUT "${CMAKE_BINARY_DIR}/monosat_src.zip"
            WORKING_DIRECTORY  "${CMAKE_SOURCE_DIR}/src/monosat/api/java/"
            )

NVIDIA/DALI cmake/Utils.cmake :247 

add_custom_command(
    TARGET ${LINT_TARGET}
    POST_BUILD
    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
    COMMAND ${LINT_COMMAND} ${LINT_EXTRA} ${LIST_SRC}
    )

Kitware/ParaView CMake/ParaViewClient.cmake :627 

add_custom_command(
    OUTPUT  "${_paraview_client_doc_OUTPUT_DIR}/${_paraview_client_doc_TARGET}.xslt"
            ${_paraview_client_doc_outputs}
    COMMAND "${CMAKE_COMMAND}"
            "-Dxmlpatterns=${qt_xmlpatterns_executable}"
            "-Dxsltproc=${ParaViewClient_xsltproc_executable}"
            "-Doutput_dir=${_paraview_client_doc_OUTPUT_DIR}"
            "-Doutput_file=${_paraview_client_doc_OUTPUT_DIR}/${_paraview_client_doc_TARGET}.xslt"
            "-Dxmls_file=${_paraview_client_doc_xmls_file}"
            -D_paraview_generate_proxy_documentation_run=ON
            -P "${_ParaViewClient_script_file}"
    DEPENDS ${_paraview_client_doc_xmls}
            "${_paraview_client_doc_xmls_file}"
            "${_ParaViewClient_script_file}"
            "${_ParaViewClient_cmake_dir}/paraview_servermanager_convert_xml.xsl"
            "${_ParaViewClient_cmake_dir}/paraview_servermanager_convert_categoryindex.xsl"
            "${_ParaViewClient_cmake_dir}/paraview_servermanager_convert_html.xsl"
            "${_ParaViewClient_cmake_dir}/paraview_servermanager_convert_wiki.xsl.in"
    WORKING_DIRECTORY "${_paraview_client_doc_OUTPUT_DIR}"
    COMMENT "Generating documentation for ${_paraview_client_doc_TARGET}")

codilime/veles cmake/openssl.cmake :16 

add_custom_command(
          OUTPUT "${OPENSSL_DIR}/crypto/buildinf.h"
          COMMAND ${PERL_EXECUTABLE} Configure VC-WIN64A
          WORKING_DIRECTORY ${OPENSSL_DIR}
          DEPENDS ${OPENSSL_DIR}
          COMMENT "Configuring OpenSSL"
          VERBATIM
      )

zeek/zeek src/CMakeLists.txt :285 

add_custom_command(
    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/DebugCmdConstants.h
           ${CMAKE_CURRENT_BINARY_DIR}/DebugCmdInfoConstants.cc
    COMMAND ${Python_EXECUTABLE} ARGS ${CMAKE_CURRENT_SOURCE_DIR}/make_dbg_constants.py
            ${CMAKE_CURRENT_SOURCE_DIR}/DebugCmdInfoConstants.in
    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/make_dbg_constants.py
            ${CMAKE_CURRENT_SOURCE_DIR}/DebugCmdInfoConstants.in
    COMMENT "[Python] Processing debug commands"
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})

sandialabs/InterSpec external_libs/pugixml-1.9/CMakeLists.txt :87 

add_custom_command(TARGET check POST_BUILD COMMAND check WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})

marsyas/marsyas doc/CMakeLists.txt :80 

add_custom_command(
	OUTPUT ${MANUAL_DIR}/marsyas-cookbook/index.html
	COMMAND ${TEXI2HTML}
	ARGS ${CMAKE_CURRENT_SOURCE_DIR}/marsyas-cookbook.texi
	WORKING_DIRECTORY ${MANUAL_DIR}
)

DIPlib/diplib doc/CMakeLists.txt :85 

add_custom_command(
         OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/diplib_docs.json"
         COMMAND "${DOXPP_PARSE_EXECUTABLE}"
         DEPENDS ${DOC_SOURCES}
         WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
   )

Tulip-Dev/tulip thirdparty/OGDF/cmake/tests.cmake :20 

add_custom_command(
  OUTPUT ${generated_path}
  COMMAND pack-resources "${generated_path}"
  WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
  COMMENT "Packing resources to compile them into the test binary"
  DEPENDS pack-resources)

gismo/gismo plugins/gsAxel/CMakeLists.txt :242 

add_custom_command (OUTPUT ${CMAKE_BINARY_DIR}/.deploy
                   COMMAND ${Axl_DIR}/dtk/bin/dtkDeploy ${Axl_DIR}/bin/axl.app -inject=${CMAKE_BINARY_DIR}/plugins
                   WORKING_DIRECTORY ${CMAKE_BINARY_DIR} )

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

add_custom_command(OUTPUT ${stamp}
            COMMAND ${PYTHON_EXECUTABLE} -m pip install . -V
            --no-cache-dir
            --disable-pip-version-check
            --no-index
            --no-deps
            --no-build-isolation
            --no-warn-script-location
            --upgrade
            --target "${abs_dest_path}"
            COMMAND ${CMAKE_COMMAND} -E touch ${stamp}
            DEPENDS  ${args_PY_SETUP_FILE} ${args_PY_SOURCES}
            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})

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

add_custom_command(
			TARGET ${TARGET} POST_BUILD
			COMMAND "${CMAKE_COMMAND}" "-DTARGET_FILE=$<TARGET_FILE:${TARGET}>"
			ARGS ${CMAKE_SOURCE_DIR}
			WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
			VERBATIM
		)

SimVascular/SimVascular Code/CMake/CppMicroServices/usFunctionAddResources.cmake :138 

add_custom_command(
    OUTPUT ${_res_zip}
    COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_CURRENT_BINARY_DIR}/us_${US_RESOURCE_TARGET}"
    COMMAND ${resource_compiler} ${cmd_line_args} ${_res_zip} ${US_RESOURCE_MODULE_NAME} ${_file_args} ${_zip_args}
    WORKING_DIRECTORY ${US_RESOURCE_WORKING_DIRECTORY}
    DEPENDS ${_cmd_deps} ${resource_compiler}
    COMMENT "Checking resource dependencies for ${US_RESOURCE_TARGET}"
    VERBATIM
  )

NERSC/timemory cmake/Modules/MacroUtilities.cmake :781 

add_custom_command(
                TARGET ${LIBRARY_TARGET_NAME}
                POST_BUILD
                COMMAND ${CMAKE_COMMAND} -E create_symlink ${BINARY_RELPATH}/${_FILENAME}
                        ${PROJECT_BINARY_DIR}/timemory/libs/${_FILENAME}
                WORKING_DIRECTORY ${PROJECT_BINARY_DIR})

GoSSIP-SJTU/TripleDoggy cmake/modules/AddLLVM.cmake :818 

add_custom_command(OUTPUT ${exported_symbol_file}
                       COMMAND ${PYTHON_EXECUTABLE} ${LLVM_MAIN_SRC_DIR}/utils/extract_symbols.py --mangling=${mangling} ${static_libs} -o ${exported_symbol_file}
                       WORKING_DIRECTORY ${LLVM_LIBRARY_OUTPUT_INTDIR}
                       DEPENDS ${LLVM_MAIN_SRC_DIR}/utils/extract_symbols.py ${static_libs}
                       VERBATIM
                       COMMENT "Generating export list for ${target}")

ceph/ceph src/ceph-node-proxy/CMakeLists.txt :10 

add_custom_command(
  OUTPUT ${CEPH_NODE_PROXY_VIRTUALENV}/bin/python
  COMMAND ${CMAKE_SOURCE_DIR}/src/tools/setup-virtualenv.sh --python=${Python3_EXECUTABLE} ${CEPH_NODE_PROXY_VIRTUALENV}
  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/src/ceph-node-proxy
  COMMENT "ceph-node-proxy venv is being created")

OSGeo/PROJ src/apps/bin_proj.cmake :25 

add_custom_command(
      OUTPUT ${link_target}
      COMMAND ${CMAKE_COMMAND} -E create_symlink ${link_source} ${link_target}
      WORKING_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}"
      DEPENDS binproj
      COMMENT "Generating invproj"
      VERBATIM
    )

jolibrain/deepdetect CMakeLists.txt :1133 

add_custom_command(
        OUTPUT ${CMAKE_BINARY_DIR}/src/onnx.pb.h ${CMAKE_BINARY_DIR}/src/onnx.pb.cc
        COMMAND LD_LIBRARY_PATH=${PROTOBUF_LIB_DIR} ${PROTOBUF_PROTOC} --proto_path=${CMAKE_BINARY_DIR}/tensorrt-oss/src/tensorrt-oss/parsers/onnx/third_party/onnx/onnx/ --cpp_out=${CMAKE_BINARY_DIR}/src ${ONNX_PROTO}
        COMMENT Generating onnx.pb.h and onnx.pb.cc
        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
        DEPENDS protobuf tensorrt-oss
    )

NickvisionApps/Parabolic cmake/helpers.cmake :32 

add_custom_command(TARGET ${OUTPUT_NAME} PRE_BUILD COMMAND "${ITSTOOL_EXECUTABLE}" -o "docs/po/${SHORT_NAME}.pot" "docs/yelp/C/*.page" WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}")

apache/trafficserver lib/Catch2/CMake/FindGcov.cmake :142 

add_custom_command(OUTPUT ${TDIR}/${FILE}.gcov
			COMMAND ${GCOV_ENV} ${GCOV_BIN} ${TDIR}/${FILE}.gcno > /dev/null
			DEPENDS ${TNAME} ${TDIR}/${FILE}.gcno
			WORKING_DIRECTORY ${FILE_PATH}
		)

hlrs-vis/covise cmake/FindGSOAP.cmake :169 

ADD_CUSTOM_COMMAND(OUTPUT ${wsdl_out}
        COMMAND ${GSOAP_WSDL2H}
        ARGS -f -p -I ${GSOAP_STDINC_DIR} -o ${wsdl_out} ${wsdl_inp}
        DEPENDS ${wsdl_inp}
        COMMENT "[GSOAP][${gsoap_output}] wsdl2h -f -p -I ${GSOAP_STDINC_DIR} -I ${inp_path} -o ${wsdl_out} ${wsdl_inp}"
        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
    )

steemit/steem libraries/wallet/CMakeLists.txt :8 

add_custom_command( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/doxygen/perlmod/DoxyDocs.pm
                      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
                      COMMAND ${DOXYGEN_EXECUTABLE}
                      DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile ${CMAKE_CURRENT_SOURCE_DIR}/include/steem/wallet/wallet.hpp )

brndnmtthws/conky 3rdparty/toluapp/cmake/lua.cmake :45 

add_custom_command(
      OUTPUT ${_exe}
      COMMAND ${GLUE_EXECUTABLE} 
      ARGS ${SRLUA_EXECUTABLE} ${_source} ${_exe}
      DEPENDS ${_source}
      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
      VERBATIM
    )

root-project/root CMakeLists.txt :600 

add_custom_command(OUTPUT tutorials/hsimple.root
                   ${hsimple_cmd}
                   WORKING_DIRECTORY tutorials
                   DEPENDS $<TARGET_FILE:root.exe> Cling Hist Tree Gpad Graf HistPainter move_artifacts)

scylladb/scylladb cmake/check_headers.cmake :43 

add_custom_command(
      OUTPUT ${src}
      DEPENDS ${CMAKE_SOURCE_DIR}/${fn}
      COMMAND ${CMAKE_COMMAND} -E echo "#include \"${fn}\"" > "${src}"
      WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
      VERBATIM)

Slicer/Slicer CMake/SlicerMacroBuildApplication.cmake :769 

add_custom_command(
            DEPENDS
              ${CTKAppLauncher_DIR}/bin/CTKAppLauncherW${CMAKE_EXECUTABLE_SUFFIX}
            OUTPUT
              ${Slicer_BINARY_DIR}/CMakeFiles/${SLICERAPP_APPLICATION_NAME}W${CMAKE_EXECUTABLE_SUFFIX}
            COMMAND ${CMAKE_COMMAND} -E copy
              ${CTKAppLauncher_DIR}/bin/CTKAppLauncherW${CMAKE_EXECUTABLE_SUFFIX}
              ${Slicer_BINARY_DIR}/CMakeFiles/${SLICERAPP_APPLICATION_NAME}W${CMAKE_EXECUTABLE_SUFFIX}
            COMMAND
              ${CTKResEdit_EXECUTABLE}
                --update-resource-ico ${Slicer_BINARY_DIR}/CMakeFiles/${SLICERAPP_APPLICATION_NAME}W${CMAKE_EXECUTABLE_SUFFIX}
                IDI_ICON1 ${SLICERAPP_WIN_ICON_FILE}
            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
            COMMENT ""
            )

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

add_custom_command(
            OUTPUT "${_unityFile}"
            COMMAND ${_unityCmd}
            DEPENDS "${_targetScript}" ${_dependencySources}
            COMMENT "Generating ${_language} unity source ${_unityFileRelPath}"
            WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" VERBATIM)

projectM-visualizer/projectm cmake/GenerateShaderResources.cmake :3 

add_custom_command(OUTPUT
            "${_output_file}"

            COMMAND ${CMAKE_COMMAND}

            ARGS
            -D "SHADER_FILES=${SHADER_FILES_ARG}"
            -D "OUTPUT_FILE=${_output_file}"
            -P "${PROJECTM_SOURCE_DIR}/cmake/GenerateShaderResourcesScript.cmake"

            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
            DEPENDS # Watch scripts and shader files for changes
            ${PROJECTM_SOURCE_DIR}/cmake/ShaderResources.hpp.in
            ${PROJECTM_SOURCE_DIR}/cmake/GenerateShaderResources.cmake
            ${PROJECTM_SOURCE_DIR}/cmake/GenerateShaderResourcesScript.cmake
            ${ARGN}
            )

google/filament third_party/dawn/src/dawn/node/CMakeLists.txt :74 

add_custom_command(
        COMMAND ${GO_EXECUTABLE} "run" "${IDLGEN_TOOL_DIR}/main.go"
                "--template" "${IDLGEN_TEMPLATE}"
                "--output"   "${IDLGEN_OUTPUT}"
                ${IDLGEN_IDLS}
        DEPENDS "${IDLGEN_TOOL_DIR}/main.go"
                ${IDLGEN_TEMPLATE}
                ${IDLGEN_DEPENDS}
                ${IDLGEN_IDLS}
        OUTPUT  ${IDLGEN_OUTPUT}
        WORKING_DIRECTORY ${IDLGEN_TOOL_DIR}
        COMMENT "Generating ${IDLGEN_OUTPUT}"
    )

percona/percona-xtrabackup plugin/group_replication/libmysqlgcs/cmake/rpcgen.cmake :132 

ADD_CUSTOM_COMMAND(OUTPUT ${x_gen_h} ${x_gen_c}
      COMMAND ${CMAKE_COMMAND} -E copy_if_different ${x_vanilla_x} ${x_tmp_x}

      #
      # Generate the header file
      # The struct definitions in the header file is for the latest version only,
      # since that is the canonical representation in the code.
      # Conversion between protocol versions is taken care of by
      # the generated xdr functions.
      #
      COMMAND ${CMAKE_COMMAND} -E remove -f ${x_gen_h}
      COMMAND ${CMAKE_COMMAND} -E remove -f ${x_tmp_h}
      COMMAND ${CMAKE_COMMAND} -DRPCGEN_EXECUTABLE=${RPCGEN_EXECUTABLE} -DXCOM_PROTO_VERS=109 -Dversion="" -Drpcgen_output=${x_tmp_h} -Dx_gen_h=${x_gen_h} -Dx_tmp_x_canonical_name=${x_tmp_x_canonical_name} -P ${enumfix}

      #
      # Generate xdr functions for all versions of the xdr protocol
      # There is one invocation of the add_version_suffix.cmake script for each version,
      # except for the last version.
      # Note that the version needs to be specified twice, once as
      # -DXCOM_PROTO_VERS=<number> and once as -Dversion="string"
      # For example, 101 corresponds to the version "_1_1" suffix
      #

      COMMAND ${CMAKE_COMMAND} -E remove -f ${x_gen_c}
      COMMAND ${CMAKE_COMMAND} -E remove -f ${x_tmp_c}
      COMMAND ${CMAKE_COMMAND} -DRPCGEN_EXECUTABLE=${RPCGEN_EXECUTABLE} -DXCOM_PROTO_VERS=100 -Dversion="_1_0" -Drpcgen_output=${x_tmp_c} -Dx_gen_c=${x_gen_c} -Dx_tmp_x_canonical_name=${x_tmp_x_canonical_name} -P ${versionfix}
      COMMAND ${CMAKE_COMMAND} -DRPCGEN_EXECUTABLE=${RPCGEN_EXECUTABLE} -DXCOM_PROTO_VERS=101 -Dversion="_1_1" -Drpcgen_output=${x_tmp_c} -Dx_gen_c=${x_gen_c} -Dx_tmp_x_canonical_name=${x_tmp_x_canonical_name} -P ${versionfix}
      COMMAND ${CMAKE_COMMAND} -DRPCGEN_EXECUTABLE=${RPCGEN_EXECUTABLE} -DXCOM_PROTO_VERS=102 -Dversion="_1_2" -Drpcgen_output=${x_tmp_c} -Dx_gen_c=${x_gen_c} -Dx_tmp_x_canonical_name=${x_tmp_x_canonical_name} -P ${versionfix}
      COMMAND ${CMAKE_COMMAND} -DRPCGEN_EXECUTABLE=${RPCGEN_EXECUTABLE} -DXCOM_PROTO_VERS=103 -Dversion="_1_3" -Drpcgen_output=${x_tmp_c} -Dx_gen_c=${x_gen_c} -Dx_tmp_x_canonical_name=${x_tmp_x_canonical_name} -P ${versionfix}
      COMMAND ${CMAKE_COMMAND} -DRPCGEN_EXECUTABLE=${RPCGEN_EXECUTABLE} -DXCOM_PROTO_VERS=104 -Dversion="_1_4" -Drpcgen_output=${x_tmp_c} -Dx_gen_c=${x_gen_c} -Dx_tmp_x_canonical_name=${x_tmp_x_canonical_name} -P ${versionfix}
      COMMAND ${CMAKE_COMMAND} -DRPCGEN_EXECUTABLE=${RPCGEN_EXECUTABLE} -DXCOM_PROTO_VERS=105 -Dversion="_1_5" -Drpcgen_output=${x_tmp_c} -Dx_gen_c=${x_gen_c} -Dx_tmp_x_canonical_name=${x_tmp_x_canonical_name} -P ${versionfix}
      COMMAND ${CMAKE_COMMAND} -DRPCGEN_EXECUTABLE=${RPCGEN_EXECUTABLE} -DXCOM_PROTO_VERS=106 -Dversion="_1_6" -Drpcgen_output=${x_tmp_c} -Dx_gen_c=${x_gen_c} -Dx_tmp_x_canonical_name=${x_tmp_x_canonical_name} -P ${versionfix}
      COMMAND ${CMAKE_COMMAND} -DRPCGEN_EXECUTABLE=${RPCGEN_EXECUTABLE} -DXCOM_PROTO_VERS=107 -Dversion="_1_7" -Drpcgen_output=${x_tmp_c} -Dx_gen_c=${x_gen_c} -Dx_tmp_x_canonical_name=${x_tmp_x_canonical_name} -P ${versionfix}
      COMMAND ${CMAKE_COMMAND} -DRPCGEN_EXECUTABLE=${RPCGEN_EXECUTABLE} -DXCOM_PROTO_VERS=108 -Dversion="_1_8" -Drpcgen_output=${x_tmp_c} -Dx_gen_c=${x_gen_c} -Dx_tmp_x_canonical_name=${x_tmp_x_canonical_name} -P ${versionfix}
      #
      # The latest version is generated twice, once with the version suffix, and once without the suffix
      # To add a new version, change the two next lines so they correspond
      # to the latest version, and add a line for the previous version above
      # this comment block.
      #
      COMMAND ${CMAKE_COMMAND} -DRPCGEN_EXECUTABLE=${RPCGEN_EXECUTABLE} -DXCOM_PROTO_VERS=109 -Dversion="_1_9" -Drpcgen_output=${x_tmp_c} -Dx_gen_c=${x_gen_c} -Dx_tmp_x_canonical_name=${x_tmp_x_canonical_name} -P ${versionfix}
      COMMAND ${CMAKE_COMMAND} -DRPCGEN_EXECUTABLE=${RPCGEN_EXECUTABLE} -DXCOM_PROTO_VERS=109 -Dversion="" -Drpcgen_output=${x_tmp_c} -Dx_gen_c=${x_gen_c} -Dx_tmp_x_canonical_name=${x_tmp_x_canonical_name} -P ${versionfix}
      WORKING_DIRECTORY ${gen_xdr_dir}

      DEPENDS
      ${x_vanilla_x})

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

add_custom_command(
        OUTPUT ${CMAKE_310_BINARY}
        COMMAND wget https://github.com/Kitware/CMake/releases/download/v3.1.0/cmake-3.1.0-Linux-x86_64.tar.gz
        COMMAND tar xfz cmake-3.1.0-Linux-x86_64.tar.gz
        COMMAND rm cmake-3.1.0-Linux-x86_64.tar.gz
        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
        COMMENT "Download CMake 3.1.0"
    )

nanocurrency/nano-node nano/ipc_flatbuffers_lib/CMakeLists.txt :58 

add_custom_command(
    OUTPUT
      ${CMAKE_CURRENT_SOURCE_DIR}/generated/flatbuffers/${flatbuffers_filename}_generated.h
    COMMAND
      "$<TARGET_FILE:flatc>" --force-empty-vectors --reflect-names --gen-mutable
      --gen-name-strings --gen-object-api --strict-json --cpp -o
      ${CMAKE_CURRENT_SOURCE_DIR}/generated/flatbuffers
      ${CMAKE_CURRENT_SOURCE_DIR}/../../api/flatbuffers/${flatbuffers_filename}.fbs
    DEPENDS
      ${CMAKE_CURRENT_SOURCE_DIR}/../../api/flatbuffers/${flatbuffers_filename}.fbs
    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})

mysql/mysql-server extra/libfido2/libfido2-1.15.0/regress/CMakeLists.txt :38 

add_custom_command(TARGET regress POST_BUILD
	    COMMAND "${CMAKE_CTEST_COMMAND}" --output-on-failure
	    WORKING_DIRECTORY ${PROJECT_BINARY_DIR})

GPSBabel/gpsbabel gui/coretool/CMakeLists.txt :26 

add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/core_strings.h
                  COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:gpsbabel> ${CMAKE_CURRENT_BINARY_DIR}
                  COMMAND ${CMAKE_COMMAND} -DQTBINDIR=${_qt_bin_dir} -DCURRENT_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR} -P ${CMAKE_CURRENT_SOURCE_DIR}/coretool.cmake
                  DEPENDS coretool gpsbabel
                  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
                  VERBATIM
                  USES_TERMINAL)

robotology/yarp extern/thrift/thrift/lib/hs/CMakeLists.txt :67 

add_custom_command(
    OUTPUT ${haskell_artifacts}
    COMMAND ${CABAL} update
    # Build dependencies first without --builddir, otherwise it fails.
    COMMAND ${CABAL} install --only-dependencies ${hs_enable_test}
    COMMAND ${CABAL} configure ${hs_optimize} ${hs_enable_test} --builddir=${CMAKE_CURRENT_BINARY_DIR}/dist
    COMMAND ${CABAL} build --builddir=${CMAKE_CURRENT_BINARY_DIR}/dist
    COMMAND ${CABAL} install --builddir=${CMAKE_CURRENT_BINARY_DIR}/dist
    COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/thrift_cabal.stamp
    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
    DEPENDS ${haskell_sources}
    COMMENT "Building Haskell library")

yandex/porto portodshim/logshim/CMakeLists.txt :9 

add_custom_command(
  OUTPUT ${TARGET}
  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
  DEPENDS ${SRCS}
  COMMAND env GOPATH=${GOPATH} GOCACHE=/tmp go build -modcacherw -buildmode=exe -o "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}"
)

apache/kudu src/kudu/subprocess/CMakeLists.txt :40 

add_custom_command(OUTPUT ${SUBPROCESS_JAR}
  COMMAND ./gradlew :kudu-subprocess:jar ${GRADLE_FLAGS}
  COMMAND cp -f
    "${JAVA_DIR}/kudu-subprocess/build/libs/kudu-subprocess-${KUDU_VERSION_NUMBER}.jar"
    "${SUBPROCESS_JAR}"
  WORKING_DIRECTORY "${JAVA_DIR}"
  DEPENDS proto_jar)

apache/qpid-proton ruby/CMakeLists.txt :72 

add_custom_command(
    OUTPUT ${GEM_FILE}
    COMMAND ${CMAKE_COMMAND} -E copy_directory ${src} ${bin}/gem
    COMMAND ${CMAKE_COMMAND} -E copy_directory ${src}/examples/ ${bin}/gem/examples
    COMMAND ${CMAKE_COMMAND} -E copy ${bin}/cprotonRUBY_wrap.c ${bin}/gem/ext/cproton/cproton.c
    COMMAND ${GEM_EXE} build qpid_proton.gemspec
    WORKING_DIRECTORY ${bin}/gem
    DEPENDS ${bin}/gem/qpid_proton.gemspec ${RUBY_SRC} ${src}/LICENSE.txt
    cproton-ruby
    )

kyubotics/coolq-http-api cmake/Modules/cotire.cmake :2690 

add_custom_command(
		OUTPUT "${_prefixFile}" "${_prefixFile}.log"
		COMMAND ${_prefixCmd}
		DEPENDS ${_unityFiles} ${_dependencySources} "${_realCompilerExe}"
		COMMENT "${_comment}"
		WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
		VERBATIM)

Icinga/icinga2 tools/mkembedconfig/CMakeLists.txt :15 

add_custom_command(
    OUTPUT ${EmbedOutput}
    COMMAND mkembedconfig
    ARGS ${EmbedInput} ${CMAKE_CURRENT_BINARY_DIR}/${EmbedOutput}
    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
    DEPENDS mkembedconfig ${EmbedInput}
  )

tlorach/nvFX samples/D3DSimple/CMakeLists.txt :36 

add_custom_command(
    OUTPUT D3DSimple_Log.txt
    COMMAND ${NVFX_BINARY_PATH}/nvFxcc
            -oD3DSimple_Log.txt
            ${D3DSimple_SOURCE_DIR}/Simple.d3dfx
    DEPENDS ${NVFX_BINARY_PATH}/nvFxcc Simple.d3dfx
    WORKING_DIRECTORY ${D3DSimple_SOURCE_DIR}
    )

pyside/Shiboken tests/minimalbinding/CMakeLists.txt :18 

add_custom_command(OUTPUT ${minimal_SRC}
COMMAND shiboken --project-file=${CMAKE_CURRENT_BINARY_DIR}/minimal-binding.txt ${GENERATOR_EXTRA_FLAGS}
DEPENDS ${minimal_TYPESYSTEM} ${CMAKE_CURRENT_SOURCE_DIR}/global.h shiboken
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMENT "Running generator for 'minimal' test binding..."
)

stanford-centaur/smt-switch cvc5/CMakeLists.txt :48 

add_custom_command(
    OUTPUT static-smt-switch-cvc5.stamp
    COMMAND
      mkdir ssc-working && cd ssc-working &&
      # create new static library that combines them all
      ${PROJECT_SOURCE_DIR}/scripts/repack-static-lib.sh "$<TARGET_FILE_NAME:smt-switch-cvc5>" "${CVC5_HOME}/build/src/libcvc5.a" "${POLYLIBXX}" "${POLYLIB}" "${CADICAL}" "../$<TARGET_FILE_NAME:smt-switch-cvc5>" &&
      # replace the original one
      mv "$<TARGET_FILE_NAME:smt-switch-cvc5>" "../$<TARGET_FILE_NAME:smt-switch-cvc5>" &&
      # now clean up the temporary directory
      cd ../ && rm -rf ssc-working
    COMMAND ${CMAKE_COMMAND} -E touch static-smt-switch-cvc5.stamp
    DEPENDS
      smt-switch-cvc5
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    VERBATIM
    )

scylladb/seastar cmake/CheckHeaders.cmake :58 

add_custom_command (
      OUTPUT ${src}
      DEPENDS ${fn}
      # silence "-Wpragma-once-outside-header"
      COMMAND sed
            -e "s/^#pragma once//"
            "${fn}" > "${src}"
      WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
      VERBATIM)

jupyter-xeus/cpp-terminal cmake/Documentation.cmake :343 

add_custom_command(
      OUTPUT ${STAMP_FILE} ${DOXYGEN_INPUT_LATEX} VERBATIM
      COMMAND ${CMAKE_COMMAND} -E make_directory ${ORIGINAL_DOXYGEN_OUTPUT_DIR}
      COMMAND "${DOXYGEN_EXECUTABLE}" "${CONFIG_FILE}"
      COMMAND ${CMAKE_COMMAND} -E touch ${STAMP_FILE}
      WORKING_DIRECTORY "${ARGS_WORKING_DIRECTORY}"
      DEPENDS "${CONFIG_FILE}" ${_sources}
      COMMENT "${ARGS_COMMENT}")

TheAssassin/AppImageLauncher src/binfmt-bypass/CMakeLists.txt :99 

add_custom_command(
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${target_name}.h
        COMMAND xxd -i $<TARGET_FILE_NAME:${target_name}> ${target_name}.h
        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
        DEPENDS ${target_name}
        VERBATIM
    )

open-eid/DigiDoc4-Client client/CMakeLists.txt :147 

add_custom_command(
		OUTPUT ${GENERATED_INCLUDE}
		COMMENT "Compiling flatbuffer for ${name}"
		COMMAND flatbuffers::flatc
			--cpp
			--scoped-enums
			-o ${CMAKE_CURRENT_BINARY_DIR}
			-I ${CMAKE_CURRENT_SOURCE_DIR}
			${SCHEMA}
		DEPENDS flatbuffers::flatc ${SCHEMA}
		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
	)

nadrino/SimpleModManager cmake/nx-utils.cmake :120 

add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${target}
            COMMAND ${__NACP_COMMAND}
            WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
            VERBATIM)

mkiol/dsnote cmake/espeak_module.cmake :7 

add_custom_command(
  OUTPUT espeakdata.tar.xz
  COMMAND sh -c "${tools_dir}/make_espeakdata_module.sh ${espeak_data_dir}/espeak-ng-data ${CMAKE_BINARY_DIR}/external/espeakdata_module ${PROJECT_BINARY_DIR}/espeakdata.tar.xz ${xz_path}"
  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
  VERBATIM
)

faheel/BigInt CMake/FindGcov.cmake :142 

add_custom_command(OUTPUT ${TDIR}/${FILE}.gcov
			COMMAND ${GCOV_ENV} ${GCOV_BIN} ${TDIR}/${FILE}.gcno > /dev/null
			DEPENDS ${TNAME} ${TDIR}/${FILE}.gcno
			WORKING_DIRECTORY ${FILE_PATH}
		)

greatscottgadgets/gr-bluetooth docs/doxygen/CMakeLists.txt :43 

add_custom_command(
    OUTPUT ${BUILT_DIRS}
    COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    COMMENT "Generating documentation with doxygen"
)

aseprite/aseprite src/desktop/osx/CMakeLists.txt :20 

add_custom_command(
  OUTPUT ${CMAKE_BINARY_DIR}/lib/AsepriteThumbnailer.qlgenerator
  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
  COMMAND ${CMAKE_COMMAND} -E make_directory lib/AsepriteThumbnailer.qlgenerator
  COMMAND ${CMAKE_COMMAND} -E make_directory lib/AsepriteThumbnailer.qlgenerator/Contents
  COMMAND ${CMAKE_COMMAND} -E make_directory lib/AsepriteThumbnailer.qlgenerator/Contents/MacOS
  COMMAND ${CMAKE_COMMAND} -E copy
             lib/AsepriteThumbnailer.framework/Versions/A/AsepriteThumbnailer
             lib/AsepriteThumbnailer.qlgenerator/Contents/MacOS
  COMMAND ${CMAKE_COMMAND} -E copy
             lib/AsepriteThumbnailer.framework/Versions/A/Resources/Info.plist
             lib/AsepriteThumbnailer.qlgenerator/Contents
  BYPRODUCTS ${CMAKE_BINARY_DIR}/lib/AsepriteThumbnailer.qlgenerator/Contents/MacOS/AsepriteThumbnailer
             ${CMAKE_BINARY_DIR}/lib/AsepriteThumbnailer.qlgenerator/Contents/Info.plist
  DEPENDS AsepriteThumbnailer)

AshamaneProject/AshamaneCore dep/cotire/CMake/cotire.cmake :2417 

add_custom_command(
		OUTPUT "${_joinedFile}"
		COMMAND ${_prefixCmd}
		DEPENDS ${_files}
		COMMENT "${_comment}"
		WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
		VERBATIM)

vseasky/VersaAssistant assimp/contrib/draco/cmake/draco_emscripten.cmake :90 

add_custom_command(OUTPUT "${glue_OUTPUT_PATH}.cpp"
                     COMMAND ${PYTHON_EXECUTABLE}
                             $ENV{EMSCRIPTEN}/tools/webidl_binder.py
                             ${glue_INPUT_IDL} ${glue_OUTPUT_PATH}
                     DEPENDS ${draco_js_dec_idl}
                     COMMENT "Generating ${glue_OUTPUT_PATH}.cpp."
                     WORKING_DIRECTORY ${draco_build}
                     VERBATIM)

astroidmail/astroid cmake/GObjectIntrospectionMacros.cmake :100 

add_custom_command(
      COMMAND ${INTROSPECTION_SCANNER}
              ${INTROSPECTION_SCANNER_ARGS}
              --namespace=${_gir_namespace}
              --nsversion=${_gir_version}
    	      --add-include-path=${CMAKE_CURRENT_BINARY_DIR}
              --output ${CMAKE_CURRENT_BINARY_DIR}/${_gir}
              ${_gir_libtool}
              ${_gir_program}
              ${_gir_libraries}
              ${_gir_packages}
              ${_gir_includepkgs}
              ${_gir_includes}
              ${_gir_export_packages}
              ${${_gir_name}_SCANNERFLAGS}
              ${${_gir_name}_CFLAGS}
              ${${_gir_name}_FILES}
      DEPENDS ${${_gir_name}_FILES}
              ${${_gir_name}_LIBS}
	      ${${_gir_name}_PROGRAM}
      OUTPUT  ${_gir}
      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
      VERBATIM
      )

satya-das/cppparser CMakeLists.txt :28 

add_custom_command(
		OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/README.md
		COMMAND ${MARKDOWN_PP} ${CMAKE_CURRENT_SOURCE_DIR}/cppparser/src/README.mdpp -o ${CMAKE_CURRENT_SOURCE_DIR}/README.md
		DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/cppparser/src/README.mdpp ${RESPATHS} ${EXAMPLE_HEADERS}
		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
	)

casadi/casadi casadi/core/CMakeLists.txt :255 

add_custom_command(
  OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/runtime/casadi_runtime_str.h"
  COMMAND  ${CMAKE_COMMAND} -D OUTPUT="${CMAKE_CURRENT_BINARY_DIR}/runtime/casadi_runtime_str.h" -D SOURCES="${ESCAPED_RUNTIME_SRC}" -P "${CMAKE_CURRENT_SOURCE_DIR}/../generate_runtime.cmake"
  DEPENDS ${RUNTIME_SRC}
  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)

rAthenaCN/rAthenaCN 3rdparty/rapidyaml/ext/c4core/cmake/c4Doxygen.cmake :87 

add_custom_command(OUTPUT ${doxyfile_out}
            COMMAND ${CMAKE_COMMAND} -E remove -f ${doxyfile_out}
            COMMAND ${CMAKE_COMMAND} -DDOXYFILE_IN=${_DOXYFILE_IN}  -DDOXYFILE_OUT=${doxyfile_out} ${defs} '-DALLVARS=${allvars}' '-DLISTVARS=${listvars}' -P ${config_script}
            DEPENDS ${_DOXYFILE_IN} ${config_script}
            COMMENT "${tgt}: generating ${doxyfile_out}"
            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})

alibaba/AliSQL cmake/install_macros.cmake :131 

ADD_CUSTOM_COMMAND(
    OUTPUT ${output}
    COMMAND ${CMAKE_COMMAND} ARGS -E remove -f ${output}
    COMMAND ${CMAKE_COMMAND} ARGS -E create_symlink 
      ${target_name} 
      ${link_name}
    WORKING_DIRECTORY ${path}
    DEPENDS ${target}
    )

KhronosGroup/SPIRV-LLVM cmake/modules/CrossCompile.cmake :10 

add_custom_command(OUTPUT ${LLVM_NATIVE_BUILD}/CMakeCache.txt
  COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" ${CMAKE_SOURCE_DIR}
  WORKING_DIRECTORY ${LLVM_NATIVE_BUILD}
  DEPENDS ${LLVM_NATIVE_BUILD}
  COMMENT "Configuring native LLVM...")

malaterre/GDCM CMake/UseDebian.cmake :139 

add_custom_command(
        OUTPUT    ${CMAKE_BINARY_DIR}/control.tar.gz
        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
        COMMAND   cmake -E tar
        ARGS      cfz ${CMAKE_BINARY_DIR}/control.tar.gz ./control ./md5sums
        DEPENDS   ${CMAKE_BINARY_DIR}/control ${CMAKE_BINARY_DIR}/md5sums
        COMMENT   "Generating control.tar.gz"
        )

KiCad/kicad-source-mirror doxygen/docset/CMakeLists.txt :57 

add_custom_command(
        COMMAND ${CMAKE_COMMAND}
            -DSRC_DOXYFILE=${SRC_DOXYFILE}
            -DDOCSET_BUNDLE_ID=${DOCSET_BUNDLE_ID}
            -DDOXY_TAG_FILE=${DOXY_TAG_FILE}
            -DDOCSET_BUNDLE_ID=${DOCSET_BUNDLE_ID}
            -DDOCSET_DOXYFILE=${DOCSET_DOXYFILE}
            -DOUTPUT_DIRECTORY="${CMAKE_CURRENT_BINARY_DIR}/doxygen"
            -DKICAD_CMAKE_MODULE_PATH=${KICAD_CMAKE_MODULE_PATH}
            -P ${KICAD_CMAKE_MODULE_PATH}/BuildSteps/CreateDocsetDoxyfile.cmake
        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/
        OUTPUT ${DOCSET_DOXYFILE}
        DEPENDS version_header
                ${SRC_DOXYFILE}
                ${KICAD_CMAKE_MODULE_PATH}/BuildSteps/CreateDocsetDoxyfile.cmake
        COMMENT "Modifying doxyfile for docset creation"
        )