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

nCine/nCine cmake/ncine_build_android.cmake :243 

add_custom_command(OUTPUT ${ANDROID_BINARY_DIR}/${ANDROID_LIBNAME} ${ANDROID_BINARY_DIR}/libncine_main.a
			COMMAND ${MSYS2_DISABLE_PATH_CONV} ${CMAKE_COMMAND} -H${CMAKE_BINARY_DIR}/android/app/src/main/cpp/ -B${ANDROID_BINARY_DIR}
				-DCMAKE_TOOLCHAIN_FILE=${NDK_DIR}/build/cmake/android.toolchain.cmake
				-DANDROID_PLATFORM=${GRADLE_MINSDK_VERSION} -DANDROID_ABI=${ARCHITECTURE}
				${RESET_FLAGS_ARGS} ${ANDROID_PASSTHROUGH_ARGS} ${ANDROID_CMAKE_ARGS} ${ANDROID_ARCH_ARGS}
			COMMAND ${CMAKE_COMMAND} --build ${ANDROID_BINARY_DIR}
			COMMENT "Compiling the Android library for ${ARCHITECTURE}")

timi-liuliang/echo thirdparty/eigen-3.3.3/cmake/EigenTesting.cmake :127 

ADD_CUSTOM_COMMAND(
    OUTPUT ${include_file}
    COMMAND ${CMAKE_COMMAND} -E echo "\\#include \\\"${host_file}\\\"" > ${include_file}
    COMMAND ${CMAKE_COMMAND} -E echo "\\#include \\\"${bc_file}.sycl\\\"" >> ${include_file}
    DEPENDS ${filename} ${bc_file}.sycl
    COMMENT "Building ComputeCpp integration header file ${include_file}"
  )

geodynamics/aspect doc/CMakeLists.txt :58 

ADD_CUSTOM_COMMAND(
    OUTPUT
      ${CMAKE_CURRENT_BINARY_DIR}/doc/manual/plugin_graph.svg
    COMMAND
      neato
        ${CMAKE_CURRENT_SOURCE_DIR}/manual/plugin_graph.dot
        -Tsvg
        -o ${CMAKE_CURRENT_BINARY_DIR}/doc/manual/plugin_graph.svg
    DEPENDS
      ${CMAKE_CURRENT_SOURCE_DIR}/manual/plugin_graph.dot
    COMMENT
      "Generating the plugin graph image."
  )

AtomicGameEngine/AtomicGameEngine Source/ThirdParty/LibCpuId/CMakeLists.txt :38 

add_custom_command (OUTPUT masm-x64.obj COMMAND ${CMAKE_ASM_MASM_COMPILER} -Fo ${CMAKE_CURRENT_BINARY_DIR}/masm-x64.obj -c ${CMAKE_CURRENT_SOURCE_DIR}/src/masm-x64.asm DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src/masm-x64.asm COMMENT "Temporary workaround for MASM")

u3d-community/U3D Source/ThirdParty/AngelScript/CMakeLists.txt :58 

add_custom_command (OUTPUT as_callfunc_x64_msvc_asm.obj COMMAND ${CMAKE_ASM_MASM_COMPILER} -Fo ${CMAKE_CURRENT_BINARY_DIR}/as_callfunc_x64_msvc_asm.obj -c ${CMAKE_CURRENT_SOURCE_DIR}/source/as_callfunc_x64_msvc_asm.asm DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/source/as_callfunc_x64_msvc_asm.asm COMMENT "Temporary workaround for MASM")

PieKing1215/FallingSandSurvival CMake/Utils.cmake :169 

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

mgerhardy/caveexpress cmake/darwin.cmake :38 

add_custom_command(TARGET ${TARGET} POST_BUILD
			COMMAND iconutil
			ARGS -c icns -o ${ICNS_TARGET} ${ICONSET_DIR}
			COMMENT "Create ${TARGET}.icns"
		)

oceancx/CXEngine cmake/cotire.cmake :2528 

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

alicevision/AliceVision src/cmake/CodeCoverage.cmake :393 

add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
        COMMAND ;
        COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
    )

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

add_custom_command(TARGET ${target} POST_BUILD 
        COMMAND ${CMAKE_COMMAND} -E copy ${TOP_LEVEL_PROJECT_DIR}/deps/+MPFR/mpfr/lib/win${_bits}/libmpfr-4.dll ${_out_dir}
        COMMENT "Copy mpfr runtime to build tree"
        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}")

godlikepanos/anki-3d-engine AnKi/Gr/CMakeLists.txt :102 

add_custom_command(
				TARGET AnKiGr
				COMMENT "NGX DLL copy ${dll_file} ${CMAKE_BINARY_DIR}/Binaries\n"
				COMMAND ${CMAKE_COMMAND} -E copy_if_different "${dll_file}" "${CMAKE_BINARY_DIR}/Binaries")

prusa3d/Prusa-Firmware CMakeLists.txt :489 

add_custom_command(
      OUTPUT ${LANG_BIN}
      # Check po file for errors _only_
      COMMAND "${Python3_EXECUTABLE}" ${CMAKE_SOURCE_DIR}/lang/lang-check.py --errors-only --map ${LANG_MAP} ${PO_FILE}
      # Build the catalog
      COMMAND "${Python3_EXECUTABLE}" ${CMAKE_SOURCE_DIR}/lang/lang-build.py ${LANG_MAP} ${PO_FILE} ${LANG_BIN}
      # Check bin size
      COMMAND ${CMAKE_COMMAND} -DLANG_MAX_SIZE=${LANG_MAX_SIZE} -DLANG_FILE=${LANG_BIN} -P
              ${PROJECT_CMAKE_DIR}/Check_lang_size.cmake
      DEPENDS ${LANG_MAP} ${PO_FILE}
      COMMENT "Generating ${variant_name}_${LANG}.bin"
      )

bambulab/BambuStudio cmake/modules/PrecompiledHeader.cmake :200 

add_custom_command(
      OUTPUT "${_pchfile}"
      COMMAND "${CMAKE_COMMAND}" -E copy "${_pch_header}" "${_pchfile}"
      DEPENDS "${_pch_header}"
      COMMENT "Updating ${_name}")

SoftFever/OrcaSlicer src/CMakeLists.txt :214 

add_custom_command(TARGET OrcaSlicer POST_BUILD
            COMMAND if not exist "${WIN_RESOURCES_SYMLINK}" "(" mklink /J "${WIN_RESOURCES_SYMLINK}" "${SLIC3R_RESOURCES_DIR_WIN}" ")"
            COMMENT "Symlinking the resources directory into the build tree"
            VERBATIM
        )

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/sdlmanpages.cmake :53 

add_custom_command(
      OUTPUT "${BUILD_MANDIR}/man3/${ARG_SYMBOL}.3"
      COMMAND "${PERL_EXECUTABLE}" "${ARG_WIKIHEADERS_PL_PATH}" "${ARG_SOURCE_DIR}" "${BUILD_WIKIDIR}" "--options=${ARG_OPTION_FILE}" "--manpath=${BUILD_MANDIR}" --copy-to-manpages ${wikiheaders_extra_args}
      DEPENDS  "${BUILD_WIKIDIR}/${ARG_SYMBOL}.md" "${ARG_WIKIHEADERS_PL_PATH}" "${ARG_OPTION_FILE}"
      COMMENT "Generating ${ARG_NAME} man pages"
    )

wrld3d/wrld-example-app cmake/templates/ios/EmbedFramework.cmake :47 

add_custom_command(
        TARGET ${target_name}
        COMMENT "Stripping simulator architectures from framework ${framework_name}"
        POST_BUILD COMMAND /bin/sh -c "${EMBED_FRAMEWORK_DIR}/strip_framework_archs.sh \${CONFIGURATION_BUILD_DIR}/\${FRAMEWORKS_FOLDER_PATH}/${framework_name}.framework/${framework_name} \"\${VALID_ARCHS}\" "
        VERBATIM
    )

Hork-Engine/Hork-Source ThirdParty/SDL3/cmake/sdlmanpages.cmake :46 

add_custom_command(
      OUTPUT "${BUILD_WIKIDIR}/${ARG_SYMBOL}.md"
      COMMAND "${CMAKE_COMMAND}" -E make_directory "${BUILD_WIKIDIR}"
      COMMAND "${PERL_EXECUTABLE}" "${ARG_WIKIHEADERS_PL_PATH}" "${ARG_SOURCE_DIR}" "${BUILD_WIKIDIR}" "--options=${ARG_OPTION_FILE}" --copy-to-wiki ${wikiheaders_extra_args}
      DEPENDS ${HEADER_FILES} "${ARG_WIKIHEADERS_PL_PATH}" "${ARG_OPTION_FILE}"
      COMMENT "Generating ${ARG_NAME} wiki markdown files"
    )

fzi-forschungszentrum-informatik/gpu-voxels icmaker/CMakeModules/FindXsd.cmake :106 

ADD_CUSTOM_COMMAND(OUTPUT ${src} ${hdr}
                           COMMAND ${XSD_EXECUTABLE} ${XSD_ARGS} "--output-dir" ${CMAKE_CURRENT_BINARY_DIR} ${infile}
                           DEPENDS ${infile}
                           COMMENT "Generating sources from XSD file ${infile}"
        )

JeanPhilippeKernel/RendererEngine Panzerfaust/CMakeLists.txt :39 

add_custom_command (TARGET ${CUSTOM_TARGET_NAME} POST_BUILD
    COMMENT "Building and Publishing Panzerfaust"
    COMMAND dotnet build ${CSPROJ_SOURCE_FILE} ${RUNTIME_IDENTIFIER} ${BUILD_CONFIGURATION} -v n
    COMMAND dotnet publish ${CSPROJ_SOURCE_FILE} ${RUNTIME_IDENTIFIER} ${BUILD_CONFIGURATION}
    VERBATIM
)

RavEngine/RavEngine deps/cmrc/CMakeRC.cmake :595 

add_custom_command(
        # This is the file we will generate
        OUTPUT "${outfile}"
        # These are the primary files that affect the output
        DEPENDS "${infile}" "${_CMRC_SCRIPT}"
        COMMAND
            "${CMAKE_COMMAND}"
                -D_CMRC_GENERATE_MODE=TRUE
                -DNAMESPACE=${lib_ns}
                -DSYMBOL=${symbol}
                "-DINPUT_FILE=${infile}"
                "-DOUTPUT_FILE=${outfile}"
                -P "${_CMRC_SCRIPT}"
        COMMENT "Generating intermediate file for ${infile}"
    )

bmwcarit/ramses cmake/ramses/flatbuffersGeneration.cmake :46 

add_custom_command(
    OUTPUT  ${generated_headers}
    COMMAND ${CMAKE_COMMAND} -E remove_directory ${flatbuffers_output_dir}
    COMMAND ${CMAKE_COMMAND} -E make_directory  ${flatbuffers_output_dir}
    COMMAND $<TARGET_FILE:flatc>
        -o ${flatbuffers_output_dir}/
        --cpp ${flatbuffers_schemas}
        --filename-suffix Gen
        --filename-ext h
        --scoped-enums
        --reflect-names
        --no-prefix
        --cpp-std c++17
    DEPENDS ${flatbuffers_schemas} $<TARGET_FILE:flatc>
    COMMENT "Generating flatbuffers header files from schemas"
    VERBATIM
)

zenustech/zeno projects/CUDA/CMakeLists.txt :51 

add_custom_command(
    TARGET copy_py
    POST_BUILD
    COMMAND 
    ${CMAKE_COMMAND} -E env ZPC_BIN_DIR="${ZPC_BIN_DIR}"
    ${ZS_OVERWRITE_PYTHON_EXECUTABLE} -m ensurepip
    COMMENT "preparing pip module"
  )

stuntrally/stuntrally cmake/Macros.cmake :102 

add_custom_command(
                COMMENT "Compiling ${name}"
                OUTPUT ${out}
                DEPENDS ${file}
                COMMAND msgfmt -o${out} ${file}
                WORKING_DIRECTORY ${dir}
        )

alpaka-group/alpaka thirdParty/catch2/CMake/FindLcov.cmake :108 

add_custom_command(OUTPUT "${OUTFILE}"
		COMMAND ${LCOV_BIN} --quiet -a ${OUTFILE}.raw --output-file ${OUTFILE}
			--base-directory ${PROJECT_SOURCE_DIR} ${LCOV_EXTRA_FLAGS}
		COMMAND ${LCOV_BIN} --quiet -r ${OUTFILE} ${LCOV_REMOVE_PATTERNS}
			--output-file ${OUTFILE} ${LCOV_EXTRA_FLAGS}
		DEPENDS ${OUTFILE}.raw
		COMMENT "Post-processing ${FILE_REL}"
	)

eclipse-ecal/ecal ecal/core/cfg/CMakeLists.txt :44 

add_custom_command(
  OUTPUT  ${YAML_PATHS}                            # Specify the output file
  COMMAND $<TARGET_FILE:${PROJECT_NAME}> --dump    # Command to run the executable
  DEPENDS ${PROJECT_NAME}                          # Ensure the executable is built before running the command
  COMMENT "Generating ${YAML_PATHS}"               # Comment to display during the build process
  VERBATIM                                         # Ensure command arguments are passed as-is
)

end2endzone/ShellAnything src/core/CMakeLists.txt :115 

add_custom_command( TARGET sa.core POST_BUILD
                    COMMAND ${CMAKE_COMMAND} -E copy_directory
                    ${CMAKE_SOURCE_DIR}/resources/configurations $<TARGET_FILE_DIR:sa.core>/../resources/configurations
                    COMMENT "Copying default configurations files database.")

svkaiser/Doom64EX cmake/FindVala.cmake :278 

add_custom_command(
      OUTPUT "${TARGET_DIR}/${fast_vapi_path}.stamp"
      BYPRODUCTS "${TARGET_DIR}/${fast_vapi_path}"
      DEPENDS
        "${source}"
        ${VALA_VAPIS}
        ${VALAC_DEPENDS}
      COMMAND "${VALA_EXECUTABLE}"
      ARGS
        "${source}"
        --fast-vapi "${TARGET_DIR}/${fast_vapi_path}"
        ${VALAFLAGS}
      COMMAND "${CMAKE_COMMAND}" ARGS -E touch "${TARGET_DIR}/${fast_vapi_path}.stamp"
      COMMENT "Generating fast VAPI ${TARGET_DIR}/${fast_vapi_path}")

AcademySoftwareFoundation/OpenShadingLanguage src/doc/CMakeLists.txt :43 

add_custom_command (OUTPUT ${mdfile}
        COMMAND ${Python3_EXECUTABLE} ${docdeep_program} -d ${_docdeep_NAME} -s docs.css
                ${_docdeep_SOURCE} > "${CMAKE_CURRENT_BINARY_DIR}/${mdfile}"
        MAIN_DEPENDENCY ${docdeep_program}
        DEPENDS ${_docdeep_SOURCE}
        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
        COMMENT "docdeep ${_docdeep_NAME}"
        )

supercollider/supercollider editors/sc-ide/CMakeLists.txt :410 

add_custom_command(TARGET SuperCollider
        POST_BUILD
        COMMAND "${CMAKE_SOURCE_DIR}/platform/windows/junctions.sh" "create" "${CMAKE_SOURCE_DIR}" "$<TARGET_FILE_DIR:SuperCollider>"
        COMMENT "Creating links to SCClassLibrary, HelpSource, examples and sounds"
      )

Morwenn/cpp-sort cmake/FindLcov.cmake :111 

add_custom_command(OUTPUT "${OUTFILE}"
		COMMAND ${LCOV_BIN} --quiet -a ${OUTFILE}.raw --output-file ${OUTFILE}
			--base-directory ${PROJECT_SOURCE_DIR} ${LCOV_EXTRA_FLAGS}
		COMMAND ${LCOV_BIN} --quiet -r ${OUTFILE} ${LCOV_REMOVE_PATTERNS}
			--output-file ${OUTFILE} ${LCOV_EXTRA_FLAGS}
		DEPENDS ${OUTFILE}.raw
		COMMENT "Post-processing ${FILE_REL}"
	)

Kitware/kwiver CMake/utils/kwiver-utils-configuration.cmake :129 

add_custom_command(
    OUTPUT  "${dest}"
    COMMAND "${CMAKE_COMMAND}" -E create_symlink ${source} ${dest}
    DEPENDS "${source}" "${dest_dir}"
    COMMENT "Symlink-configuring ${name} file \"${source}\" -> \"${dest}\""
    )

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 docs/legate/CMakeLists.txt :32 

add_custom_command(OUTPUT "${DOXYGEN_INDEX_FILE}" DEPENDS "${DOXYFILE_OUT}"
                   COMMAND "${DOXYGEN_EXECUTABLE}" "${DOXYFILE_OUT}"
                   COMMENT "Generating doxygen output")

MaaAssistantArknights/MaaAssistantArknights cmake/utils.cmake :52 

add_custom_command(
            TARGET ${TARGET_NAME}
            POST_BUILD
            COMMAND ${CMAKE_COMMAND} -E echo "Creating resource directory link for ${TARGET_NAME}..."
            COMMAND ${CMAKE_COMMAND} -E remove_directory "${OUTPUT_DIR}/resource"
            COMMAND cmd /c "mklink /J \"${OUTPUT_DIR}/resource\" \"${PROJECT_SOURCE_DIR}/resource\""
            COMMAND ${CMAKE_COMMAND} -E echo "Resource directory link created successfully"
            COMMENT "Creating junction for resource directory for ${TARGET_NAME}"
        )

maidsafe-archive/MaidSafe cmake_modules/utils.cmake :919 

add_custom_command(OUTPUT ${OutputFile}
                     COMMAND ${CMAKE_COMMAND} -DOutputFile="${OutputFile}"
                                              -DInputFile="${InputFile}"
                                              -P ${ConfigureCMakeFile}
                     DEPENDS ${MetaFile}
                             ${IntermediateOutputFiles}
                             ${InputFile}
                             ${ConfigureCMakeFile}
                     COMMENT "Configuring message_types.h")

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"
        )

RichieSams/FiberTaskingLib third_party/catch2/CMake/FindLcov.cmake :261 

add_custom_command(OUTPUT ${OUTFILE}
			COMMAND test -f "${TDIR}/${FILE}.gcda"
				&& ${GCOV_ENV} ${GENINFO_BIN} --quiet --base-directory
					${PROJECT_SOURCE_DIR} --gcov-tool ${GCOV_BIN}
					--output-filename ${OUTFILE} ${GENINFO_EXTERN_FLAG}
					${TDIR}/${FILE}.gcda
				|| cp ${OUTFILE}.init ${OUTFILE}
			DEPENDS ${TNAME} ${TNAME}-capture-init
			COMMENT "Capturing coverage data for ${FILE}"
		)

baidu/bigflow cmake/generic.cmake :120 

ADD_CUSTOM_COMMAND(
      OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.cc"
             "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.h"
      COMMAND  ${Protobuf_PROTOC_EXECUTABLE}
      ARGS "--cpp_out=${DLL_EXPORT_DECL}${CMAKE_BINARY_DIR}" ${_protobuf_include_path} ${ABS_FIL}
      DEPENDS ${ABS_FIL} ${Protobuf_PROTOC_EXECUTABLE}
      COMMENT "Running C++ protocol buffer compiler on ${FIL}"
      VERBATIM )

ml-explore/mlx mlx/backend/metal/kernels/CMakeLists.txt :129 

add_custom_command(
  OUTPUT ${MLX_METAL_PATH}/mlx.metallib
  COMMAND xcrun -sdk macosx metallib ${KERNEL_AIR} -o
          ${MLX_METAL_PATH}/mlx.metallib
  DEPENDS ${KERNEL_AIR}
  COMMENT "Building mlx.metallib"
  VERBATIM)

facebook/folly build/fbcode_builder/CMake/RustStaticLibrary.cmake :488 

add_custom_command(
    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/rust/cxx.h"
    COMMAND
      "${cxxbridge}" --header --output "${CMAKE_CURRENT_BINARY_DIR}/rust/cxx.h"
    DEPENDS "cxxbridge_v${cxx_required_version}"
    COMMENT "Generating rust/cxx.h header"
  )

openvinotoolkit/openvino cmake/developer_package/clang_format/clang_format.cmake :84 

add_custom_command(
            OUTPUT
            "${output_file}"
            COMMAND
            "${CMAKE_COMMAND}"
            -D "CLANG_FORMAT=${CLANG_FORMAT}"
            -D "INPUT_FILE=${source_file}"
            -D "OUTPUT_FILE=${output_file}"
            -P "${OpenVINODeveloperScripts_DIR}/clang_format/clang_format_check.cmake"
            DEPENDS
            "${source_file}"
            "${OpenVINODeveloperScripts_DIR}/clang_format/clang_format_check.cmake"
            COMMENT
            "[clang-format] ${source_file}"
            VERBATIM)

gnss-sdr/gnss-sdr src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/cmake/Modules/VolkPython.cmake :308 

add_custom_command(
                OUTPUT ${pyexefile} DEPENDS ${pyfile}
                COMMAND ${PYTHON_EXECUTABLE} -c
                "open('${pyexefile}','w').write(r'\#!${pyexe_native}'+'\\n'+open('${pyfile}').read())"
                COMMENT "Shebangin ${pyfile_name}"
                VERBATIM
            )

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}"
        )

psi4/psi4 doc/sphinxman/CMakeLists.txt :165 

add_custom_command(
        COMMAND ${CMAKE_COMMAND} -E make_directory source/autodir_options_c
        COMMAND ${PERL_EXECUTABLE} ${CCSD}/document_options_c.pl ${CCSD}
        OUTPUT  ${CCBD}/source/autodoc_abbr_options_c.rst
                ${CCBD}/source/autodoc_glossary_options_c.rst
                ${CCBD}/source/autodoc_options_c_bymodule.rst
                ${CCBD}/source/autodir_options_c/module__scf.rst  # representative
                ${CCBD}/source/autodir_options_c/scf__guess.rst  # representative
        DEPENDS ${CCSD}/document_options_c.pl
                ${psi4_SOURCE_DIR}/psi4/src/read_options.cc
        COMMENT "Autodoc options c-side")

ByteWelder/Tactility Libraries/elf_loader/elf_loader.cmake :63 

add_custom_command(OUTPUT elf_app
        COMMAND ${CMAKE_C_COMPILER} ${cflags} ${elf_libs} -o ${elf_app}
        COMMAND ${CMAKE_STRIP} ${strip_flags} ${elf_app}
        DEPENDS ${elf_dependeces}
        COMMENT "Build ELF: ${elf_app}"
        )

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/grpc-cmake/protobuf_generate_grpc.cmake :188 

add_custom_command(
      OUTPUT ${_generated_srcs}
      COMMAND $<TARGET_FILE:protoc>
      ARGS --${protobuf_generate_grpc_LANGUAGE}_out ${_dll_export_decl}${protobuf_generate_grpc_PROTOC_OUT_DIR}
           --grpc_out ${_dll_export_decl}${protobuf_generate_grpc_PROTOC_OUT_DIR}
           --plugin=protoc-gen-grpc=$<TARGET_FILE:${protobuf_generate_grpc_PLUGIN}>
           ${_dll_desc_out} ${_protobuf_include_path} ${_abs_file}
      DEPENDS ${_abs_file} protoc ${protobuf_generate_grpc_PLUGIN}
      COMMENT "Running ${protobuf_generate_grpc_LANGUAGE} protocol buffer compiler on ${_proto}"
      VERBATIM)

nedrysoft/pingnoo cmake/pingnoo.cmake :572 

add_custom_command(OUTPUT ${outputDir}/${outputFile}
        COMMENT "Compiling ${sourceFilename}"
        COMMAND ${lrelease} ${sourceFile} -silent -qm ${outputDir}/${outputFile}
        DEPENDS ${sourceFile})

NVIDIA/DALI cmake/modules/FindProtobuf.cmake :180 

add_custom_command(
      OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.cc"
             "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.h"
      COMMAND  ${Protobuf_PROTOC_EXECUTABLE}
      ARGS "--cpp_out=${DLL_EXPORT_DECL}${CMAKE_CURRENT_BINARY_DIR}" ${_protobuf_include_path} ${ABS_FIL}
      DEPENDS ${ABS_FIL} ${Protobuf_PROTOC_EXECUTABLE}
      COMMENT "Running C++ protocol buffer compiler on ${FIL}"
      VERBATIM )

gscept/nebula extlibs/scripts/create_resource.cmake :103 

add_custom_command(
    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${lib}/all_res.bin
    COMMAND cat ${input_paths} > ${CMAKE_CURRENT_BINARY_DIR}/${lib}/all_res.bin
    COMMENT Concatenate ${lib} resource file with all resources.
    DEPENDS ${input_paths}
  )

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}")

scanner-research/scanner cmake/Modules/FindSaneProtobuf.cmake :164 

add_custom_command(
        OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${DIR_FIL}/${FIL_WE}.pb.cc"
        "${CMAKE_CURRENT_BINARY_DIR}/${DIR_FIL}/${FIL_WE}.pb.h"
        COMMAND  ${PROTOBUF_PROTOC_EXECUTABLE}
        ARGS --cpp_out  ${CMAKE_CURRENT_BINARY_DIR} ${_protobuf_include_path} ${ABS_FIL}
        DEPENDS ${ABS_FIL} ${PROTOBUF_PROTOC_EXECUTABLE}
        COMMENT "Running C++ protocol buffer compiler on ${FIL}"
        VERBATIM )

codilime/veles CMakeLists.txt :566 

add_custom_command(
      TARGET main_exe POST_BUILD
      COMMAND ${CMAKE_COMMAND} -E copy_if_different
          "${OPENSSL_DLL_DIR}/libeay32.dll"
          "${OPENSSL_DLL_DIR}/ssleay32.dll"
          ${WINDOWS_APPLICATION_OUT_DIRECTORY}
      COMMENT "Copying OpenSSL DLLs"
  )

ukoethe/vigra config/VigraAddTest.cmake :105 

add_custom_command(
            TARGET ${target}
            POST_BUILD
            COMMAND ${VIGRA_TEST_SCRIPT} ARGS ${VIGRA_CONFIGURATION}
            COMMENT "Running ${target}")

zeek/zeek src/CMakeLists.txt :29 

add_custom_command(
        OUTPUT ${outFile}
        COMMAND ${SED_EXE} ARGS ${args}
        DEPENDS ${inFile}
        COMMENT "[sed] replacing stuff in ${inFile}")

sandialabs/InterSpec target/osx/CMakeLists.txt :97 

add_custom_command(
    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/MainMenu.nib"
    COMMAND
        ${IBTOOL} --errors --warnings --notices --output-format
            human-readable-text --compile
            "${CMAKE_CURRENT_BINARY_DIR}/MainMenu.nib"
            "${CMAKE_CURRENT_SOURCE_DIR}/en.lproj/MainMenu.xib"
    COMMENT "Compiling MainMenu.xib"
)

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 cmake/CodeCoverage.cmake :175 

add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
        COMMAND ;
        COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
    )

awawa-dev/HyperHDR cmake/cmake_modules/FindFlatBuffers.cmake :45 

add_custom_command(OUTPUT ${FLATC_OUTPUT}
        COMMAND ${FLATBUFFERS_FLATC_EXECUTABLE}
        ARGS -c -o "${CMAKE_CURRENT_BINARY_DIR}/" ${FILE}
        DEPENDS ${FILE}
        COMMENT "Building C++ header for ${FILE}"
        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})

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 source/tools/timemory-compiler-instrument/CMakeLists.txt :114 

add_custom_command(
    TARGET ${LIB_TARGET}
    POST_BUILD
    COMMAND
        ${CMAKE_COMMAND} -E create_symlink
        compiler/lib${LIB_TARGET}${CMAKE_${LIB_TYPE}_LIBRARY_SUFFIX}
        ${PROJECT_BINARY_DIR}/lib${LIB_TARGET}${CMAKE_${LIB_TYPE}_LIBRARY_SUFFIX}
    WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
    COMMENT "Creating library symlink lib${LIB_TARGET}${CMAKE_${LIB_TYPE}_LIBRARY_SUFFIX}"
    )

emsec/hal cmake/CodeCoverage.cmake :202 

add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
                        COMMAND ;
                        COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
                        )

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}")

WerWolv/ImHex plugins/script_loader/support/dotnet/CMakeLists.txt :8 

add_custom_command(
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/../../${name}.dll
        COMMAND ${DOTNET_EXECUTABLE} build ${CMAKE_CURRENT_SOURCE_DIR}/${name}/${name}.csproj -nologo -consoleLoggerParameters:NoSummary -verbosity:quiet -c Release -o ${CMAKE_CURRENT_BINARY_DIR}/../..
        DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${name}/${name}.csproj ${sources}
        COMMENT "Building ${name}.dll"
    )

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")

catchorg/Catch2 CMake/FindLcov.cmake :261 

add_custom_command(OUTPUT ${OUTFILE}
			COMMAND test -f "${TDIR}/${FILE}.gcda"
				&& ${GCOV_ENV} ${GENINFO_BIN} --quiet --base-directory
					${PROJECT_SOURCE_DIR} --gcov-tool ${GCOV_BIN}
					--output-filename ${OUTFILE} ${GENINFO_EXTERN_FLAG}
					${TDIR}/${FILE}.gcda
				|| cp ${OUTFILE}.init ${OUTFILE}
			DEPENDS ${TNAME} ${TNAME}-capture-init
			COMMENT "Capturing coverage data for ${FILE}"
		)

gnuradio/gnuradio cmake/Modules/GrPybind.cmake :287 

add_custom_command(
            OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/extracted_docstrings.json
            COMMAND
                ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/docs/doxygen/update_pydoc.py
                "scrape" "--xml_path" ${PROJECT_BINARY_DIR}/docs/doxygen/xml "--json_path"
                ${CMAKE_CURRENT_BINARY_DIR}/extracted_docstrings.json
            COMMENT "Scraping generated documentation for docstrings ..."
            DEPENDS gnuradio-${MODULE_NAME} doxygen_target)

TigerVNC/tigervnc media/CMakeLists.txt :40 

add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/icons/tigervnc.ico
    COMMAND ${CONVERT_EXECUTABLE} ${ICO_LEGACY} ${ICO_NORMAL}
      ${CMAKE_CURRENT_SOURCE_DIR}/icons/tigervnc.ico
    DEPENDS ${ICO_DEPENDS}
    COMMENT "Generating icons/tigervnc.ico")

opensim-org/opensim-core Bindings/Python/CMakeLists.txt :92 

add_custom_command(
        OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${OSIMSWIGPY_MODULE}.py"
            ${_output_cxx_file} ${_output_header_file}
        COMMAND ${SWIG_EXECUTABLE}
            #-debug-tmused # Which typemaps were used?
            -v # verbose
            -o ${_output_cxx_file}
            ${SWIG_DOXYGEN_STRING}
            -outdir "${CMAKE_CURRENT_BINARY_DIR}"
            ${_swig_common_args}
        DEPENDS ${_${OSIMSWIGPY_MODULE}_dependencies}
            COMMENT "Generating python bindings source code with SWIG: ${OSIMSWIGPY_MODULE} module."
        )

AcademySoftwareFoundation/openvdb cmake/config/OpenVDBCXX.cmake :358 

add_custom_command(TARGET gcov_html POST_BUILD
      COMMAND ;
      COMMENT "Open ./gcov_html/index.html in your browser to view the coverage report."
    )

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
    )

hlrs-vis/covise cmake/cef_macros.cmake :243 

add_custom_command(
    TARGET ${target}
    POST_BUILD
    COMMAND "mt.exe" -nologo
            -manifest \"${manifest_path}/${target}.${extension}.manifest\" \"${manifest_path}/compatibility.manifest\"
            -outputresource:"${CEF_TARGET_OUT_DIR}/${target}.${extension}"\;\#1
    COMMENT "Adding manifest..."
    )

vengi-voxel/vengi cmake/macros.cmake :31 

add_custom_command(
			OUTPUT ${OUTPUT_FILE}
			COMMAND
				binary_to_compressed_c
				${INPUT_FILE}
				${NAME} > ${OUTPUT_FILE}
			DEPENDS ${INPUT_FILE} binary_to_compressed_c
			COMMENT "Generate c header for compressed ${INPUT_FILE} in ${OUTPUT_FILE}"
			VERBATIM
		)

steemit/steem tests/CopyResourcesToBuildTree.cmake :39 

add_custom_command(TARGET ${_target}
						POST_BUILD
						COMMAND
						${CMAKE_COMMAND}
						ARGS -E make_directory "${_path${_config}}/"
						COMMENT "Creating directory ${_path${_config}}/")

brndnmtthws/conky cmake/CodeCoverage.cmake :289 

add_custom_command(
    TARGET ${Coverage_NAME} POST_BUILD
    COMMAND ;
    COMMENT "Lcov code coverage info report saved in ${Coverage_NAME}.txt.")

root-project/root CMakeLists.txt :361 

add_custom_command(OUTPUT ${artifacts_out}
      COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_SOURCE_DIR}/${dir_to_copy} ${CMAKE_BINARY_DIR}/${dir_to_copy}
      COMMENT "Copy ${dir_to_copy}"
      DEPENDS ${artifacts_in})

facebookincubator/velox velox/experimental/breeze/cmake/cuda.cmake :58 

add_custom_command(
    OUTPUT ${target}.o
    COMMAND
      ${NVCC_EXECUTABLE} -x cu ${CMAKE_NVCC_FLAGS} ${NDEBUG_DEFINE} -DPLATFORM_CUDA
      -DCUDA_PLATFORM_SPECIALIZATION_HEADER=${CUDA_PLATFORM_SPECIALIZATION_HEADER}
      -I${CMAKE_SOURCE_DIR} ${CMAKE_CXX_FLAGS} ${COMPILER_WARN_FLAGS} ${OPT_FLAGS} ${CUDA_OPT_FLAGS}
      ${arg_FLAGS} -std=c++17 -c ${source} -MD -MF ${target}.o.d -o ${target}.o
    DEPFILE ${target}.o.d
    DEPENDS ${arg_DEPENDS}
    COMMENT "Building CUDA object ${target}.o"
  )

CLIUtils/CLI11 cmake/CodeCoverage.cmake :425 

add_custom_command(
    TARGET ${Coverage_NAME}
    POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E echo
            "Lcov code coverage info report saved in ${Coverage_NAME}.info."
    COMMENT ${GCOVR_XML_CMD_COMMENT})

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)

Oneflow-Inc/oneflow cmake/oneflow.cmake :30 

add_custom_command(
      OUTPUT ${of_e_h_expanded}
      COMMAND ${CMAKE_C_COMPILER} ARGS -E -I"${PROJECT_SOURCE_DIR}" -I"${PROJECT_BINARY_DIR}" -o
              "${of_e_h_expanded}" "${oneflow_hdr_to_be_expanded}"
      DEPENDS ${oneflow_hdr_to_be_expanded}
      COMMENT "Expanding macros in ${oneflow_hdr_to_be_expanded}")

google/filament filament/CMakeLists.txt :428 

add_custom_command(
                    OUTPUT ${output_path_multiview}
                    COMMAND matc ${MATC_BASE_FLAGS} -PstereoscopicType=multiview -o ${output_path_multiview} ${fullname}
                    MAIN_DEPENDENCY ${fullname}
                    DEPENDS matc
                    COMMENT "Compiling material ${fullname} (Multiview)"
            )

percona/percona-xtrabackup CMakeLists.txt :2525 

ADD_CUSTOM_COMMAND(
  OUTPUT ${CMAKE_BINARY_DIR}/Docs/INFO_BIN
  COMMAND ${CMAKE_COMMAND}
  ${MYSQLD_EXECUTABLE_FOR_INFO_BIN}
  -DCMAKE_BUILD_TYPE=$<CONFIG>
  -P ${CMAKE_SOURCE_DIR}/cmake/info_bin.cmake
  COMMENT "Generating Docs/INFO_BIN"
  DEPENDS ${CMAKE_BINARY_DIR}/CMakeCache.txt
  )

NREL/EnergyPlus third_party/btwxt/cmake/FindLcov.cmake :264 

add_custom_command(OUTPUT ${OUTFILE}
				COMMAND test -f "${TDIR}/${FILE}.gcda"
				&& ${GCOV_ENV} ${GENINFO_BIN} --quiet --base-directory
				${PROJECT_SOURCE_DIR} --gcov-tool ${GCOV_BIN}
				--output-filename ${OUTFILE} ${GENINFO_EXTERN_FLAG}
				${TDIR}/${FILE}.gcda
				|| cp ${OUTFILE}.init ${OUTFILE}
				DEPENDS ${TNAME} ${TNAME}-capture-init
				COMMENT "Capturing coverage data for ${FILE}"
				)

Devsh-Graphics-Programming/Nabla src/nbl/builtin/utils.cmake :141 

add_custom_command(OUTPUT "${NBL_BUILTIN_RESOURCES_H}" "${NBL_BUILTIN_RESOURCE_DATA_CPP}" "${NBL_BUILTIN_DATA_ARCHIVE_H}" "${NBL_BUILTIN_DATA_ARCHIVE_CPP}"
		COMMAND "${_Python3_EXECUTABLE}" "${NBL_BUILTIN_HEADER_GEN_PY}" ${NBL_BUILTIN_RESOURCES_COMMON_ARGS} --outputBuiltinPath "${NBL_BUILTIN_RESOURCES_H}" --outputArchivePath "${NBL_BUILTIN_DATA_ARCHIVE_H}" --archiveBundlePath "${_BUNDLE_ARCHIVE_ABSOLUTE_PATH_}" --guardSuffix "${_GUARD_SUFFIX_}" --isSharedLibrary "${_SHARED_}"
		COMMAND "${_Python3_EXECUTABLE}" "${NBL_BUILTIN_DATA_GEN_PY}" ${NBL_BUILTIN_RESOURCES_COMMON_ARGS} --outputBuiltinPath "${NBL_BUILTIN_RESOURCE_DATA_CPP}" --outputArchivePath "${NBL_BUILTIN_DATA_ARCHIVE_CPP}" --bundleAbsoluteEntryPath "${_BUNDLE_SEARCH_DIRECTORY_}/${_BUNDLE_ARCHIVE_ABSOLUTE_PATH_}" --correspondingHeaderFile "${NBL_BS_HEADER_FILENAME}" --xxHash256Exe "$<${_NBL_BR_RUNTIME_HASH_}:$<TARGET_FILE:xxHash256>>"
		COMMENT "Generating \"${_TARGET_NAME_}\"'s sources & headers"
		DEPENDS ${NBL_DEPENDENCY_FILES}
		VERBATIM
	)

mysql/mysql-server cmake/protobuf_proto_compile.cmake :142 

ADD_CUSTOM_COMMAND(
      OUTPUT "${GENERATED_CC_FILE}"
             "${GENERATED_H_FILE}"
             ${ADDITIONAL_OUTPUTS}
      COMMAND ${PROTOBUF_PROTOC_EXECUTABLE}
      ARGS --cpp_out "${CPP_OUT_PREFIX}${GENERATE_OUTPUT_DIRECTORY}"
           ${ADDITIONAL_ARGS}
           -I "${PROTOBUF_INCLUDE_DIR}"
           ${PROTOC_ADDITION_OPTIONS}
           ${FULL_PATH_PROTO_FILE}
      DEPENDS
           ${FULL_PATH_PROTO_FILE}
           ${PROTOBUF_PROTOC_EXECUTABLE}
           ${GENERATE_DEPENDENCIES}
      COMMENT
      "Running C++ protobuf compiler on ${PROTO_FILE} ${GENERATE_ADDITIONAL_COMMENT}"
      VERBATIM)

winsoft666/QWebView dep/cef_binary_74.1.19+gb62bacf+chromium-74.0.3729.157_windows32/cmake/cef_macros.cmake :243 

add_custom_command(
    TARGET ${target}
    POST_BUILD
    COMMAND "mt.exe" -nologo
            -manifest \"${manifest_path}/${target}.${extension}.manifest\" \"${manifest_path}/compatibility.manifest\"
            -outputresource:"${CEF_TARGET_OUT_DIR}/${target}.${extension}"\;\#1
    COMMENT "Adding manifest..."
    )

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")

mysql/mysql-router src/router/tests/CMakeLists.txt :59 

add_custom_command(TARGET test_router_mysqlrouter_app
      COMMAND ${CMAKE_COMMAND} -E copy ${config_file} ${MySQLRouter_BINARY_STAGE_DIR}/etc/
      COMMENT "Copying Router test data: ${config_file}"
    )

apache/thrift compiler/cpp/CMakeLists.txt :135 

add_custom_command(OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/thrift${CMAKE_EXECUTABLE_SUFFIX}"
    DEPENDS thrift-compiler
    COMMAND ${CMAKE_COMMAND} -E copy "$<TARGET_FILE:thrift-compiler>" "${CMAKE_CURRENT_SOURCE_DIR}/"
    COMMENT "Copying the thrift compiler to the source tree for use by downstream targets")

apache/kudu cmake_modules/FindProtobuf.cmake :162 

add_custom_command(
      OUTPUT "${PROTO_CC_OUT}" "${PROTO_H_OUT}"
      COMMAND  ${PROTOBUF_PROTOC_EXECUTABLE}
      ARGS
        --plugin $<TARGET_FILE:protoc-gen-insertions>
        --cpp_out ${ARG_BINARY_ROOT}
        --insertions_out ${ARG_BINARY_ROOT}
        --proto_path ${ARG_SOURCE_ROOT}
        # Used to find built-in .proto files (e.g. FileDescriptorProto)
        --proto_path ${PROTOBUF_INCLUDE_DIR}
        ${EXTRA_PROTO_PATH_ARGS} ${ABS_FIL}
      DEPENDS ${ABS_FIL} protoc-gen-insertions
      COMMENT "Running C++ protocol buffer compiler on ${FIL}"
      VERBATIM )

facebook/fbthrift build/fbcode_builder/CMake/RustStaticLibrary.cmake :512 

add_custom_command(
    OUTPUT
      "${CMAKE_CURRENT_BINARY_DIR}/${cxx_header}"
      "${CMAKE_CURRENT_BINARY_DIR}/${cxx_source}"
    COMMAND
      ${cxxbridge} ${rust_source_path}
        --header --output "${CMAKE_CURRENT_BINARY_DIR}/${cxx_header}"
    COMMAND
      ${cxxbridge} ${rust_source_path}
        --output "${CMAKE_CURRENT_BINARY_DIR}/${cxx_source}"
        --include "${cxx_header}"
    DEPENDS "cxxbridge_v${cxx_required_version}" "${rust_source_path}"
    COMMENT "Generating cxx bindings for crate ${crate_name}"
  )

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)