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

timi-liuliang/echo editor/Qt/5.10.0/msvc2017_64/lib/cmake/Qt5DBus/Qt5DBusMacros.cmake :60 

add_custom_command(OUTPUT "${_impl}" "${_header}"
        COMMAND ${Qt5DBus_QDBUSXML2CPP_EXECUTABLE} ${_params} -p ${_basename} ${_infile}
        DEPENDS ${_infile} VERBATIM)

albertz/openlierox PCHSupport_26.cmake :240 

ADD_CUSTOM_COMMAND(
    OUTPUT ${_output} 	
    COMMAND ${_command}
    DEPENDS ${_input}   ${CMAKE_CURRENT_BINARY_DIR}/${_name} ${_targetName}_pch_dephelp
   )

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

novelrt/NovelRT cmake/CopyRuntimeDependencies.cmake :177 

add_custom_command(TARGET ${TARGET}
          POST_BUILD
          COMMAND ${CMAKE_COMMAND} -P copy_${lib_safe_name}_to_${TARGET}$<$<BOOL:${multi_config}>:_$<CONFIG>>.cmake
          DEPENDS $<TARGET_FILE:${TARGET}>
        )

Oslandia/SFCGAL src/CMakeLists.txt :7 

add_custom_command(TARGET copy
        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_SOURCE_DIR}/src/${header} ${CMAKE_BINARY_DIR}/include/SFCGAL/${header} DEPENDS ${CMAKE_SOURCE_DIR}/src/${header})

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 cmake/f3dEmbed.cmake :13 

add_custom_command(
    OUTPUT  "${CMAKE_CURRENT_BINARY_DIR}/${_embed_NAME}.h"
            "${CMAKE_CURRENT_BINARY_DIR}/${_embed_NAME}.cxx"
    DEPENDS "${_embed_script_file}"
            "${_embed_INPUT}"
    COMMAND "${CMAKE_COMMAND}"
            "-Dbinary_dir=${CMAKE_CURRENT_BINARY_DIR}"
            "-Dsource_file=${_embed_INPUT}"
            "-Doutput_name=${_embed_NAME}"
            "-D_embed_run=ON"
            -P "${_embed_script_file}")

prusa3d/PrusaSlicer CMakeLists.txt :555 

add_custom_command(
        TARGET gettext_po_to_mo PRE_BUILD
        COMMAND msgfmt ARGS --check-format -o ${mo_file} ${po_file}
        #COMMAND msgfmt ARGS --check-compatibility -o ${mo_file} ${po_file}
        DEPENDS ${po_file}
    )

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 CMake/Utils/PrecompiledHeader.cmake :296 

ADD_CUSTOM_COMMAND(
      OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${_name}"
      COMMAND ${CMAKE_COMMAND} -E copy_if_different "${_input}" "${CMAKE_CURRENT_BINARY_DIR}/${_name}" # ensure same directory! Required by gcc
      DEPENDS "${_input}"
      )

godlikepanos/anki-3d-engine ThirdParty/Jolt/TestFramework/TestFramework.cmake :263 

add_custom_command(OUTPUT ${SPV_SHADER}
				COMMAND ${Vulkan_GLSLC_EXECUTABLE} ${SHADER} -o ${SPV_SHADER}
				DEPENDS ${SHADER}
				COMMENT "Compiling ${SHADER}")

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

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

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

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

cnr-isti-vclab/meshlab unsupported/plugins_unsupported/external/CoMISo/cmake/FindQt4.cmake :1089 

ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
                         COMMAND ${QT_MOC_EXECUTABLE}
                         ARGS ${moc_flags} ${moc_options} -o ${outfile} ${infile}
                         DEPENDS ${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
)

overte-org/overte cmake/modules/FindQt5LinguistToolsMacros.cmake :104 

add_custom_command(OUTPUT ${qm}
            COMMAND ${Qt5_LRELEASE_EXECUTABLE}
            ARGS ${_abs_FILE} -qm ${qm}
            DEPENDS ${_abs_FILE} VERBATIM
        )

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

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
)

microsoft/Extensible-Storage-Engine dev/ese/src/ese/server/CMakeLists.txt :5 

add_custom_command(
    OUTPUT
        ${GEN_OUTPUT_DIRECTORY}/ese/jetapitable.cxx
    COMMAND ${CMAKE_COMMAND} -E
        touch_nocreate ${GEN_OUTPUT_DIRECTORY}/ese/jetapitable.cxx
    DEPENDS
        gen_jetapitable
)

LLNL/zfp python/scikit-build-cmake/UsePythonExtensions.cmake :169 

add_custom_command(
        OUTPUT ${_source_we}
        COMMAND ${PYTHON_EXECUTABLE} -c "${_tempita_command}"
        DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${_source}"
                ${_args_DEPENDS}
      )

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

ZDoom/gzdoom src/CMakeLists.txt :513 

add_custom_command( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/xlat_parser.c ${CMAKE_CURRENT_BINARY_DIR}/xlat_parser.h
	COMMAND lemon -C${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/gamedata/xlat/xlat_parser.y
	DEPENDS lemon ${CMAKE_CURRENT_SOURCE_DIR}/gamedata/xlat/xlat_parser.y )

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/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/curl/docs/libcurl/CMakeLists.txt :45 

add_custom_command(OUTPUT "${_pdffile}"
      COMMAND groff -Tps -man "${_srcfile}" > "${_psfile}"
      COMMAND ps2pdf "${_psfile}" "${_pdffile}"
      COMMAND "${CMAKE_COMMAND}" -E remove "${_psfile}"
      DEPENDS "${_srcfile}"
      #BYPRODUCTS "${_psfile}"
      VERBATIM
    )

NREL/OpenStudio ProjectMacros.cmake :226 

add_custom_command(
      OUTPUT "${SWIG_WRAPPER}"
      COMMAND ${CMAKE_COMMAND} -E env SWIG_DIR="${SWIG_DIR}"
              "${SWIG_EXECUTABLE}"
              "-ruby" "-c++" "-fvirtual" "-I${PROJECT_SOURCE_DIR}/src" "-I${PROJECT_BINARY_DIR}/src" "${extra_includes}" "${extra_includes2}" ${RUBY_AUTODOC}
              -module "${MODULE}" -initname "${LOWER_NAME}"
              "-I${PROJECT_SOURCE_DIR}/ruby"
              -o "${SWIG_WRAPPER_FULL_PATH}"
              "${SWIG_DEFINES}" ${SWIG_COMMON} "${KEY_I_FILE}"
      DEPENDS ${this_depends}
    )

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
)

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

liminchen/OptCuts ext/libigl/external/cgal/src/CGAL_Project/demo/Periodic_3_triangulation_3/CMakeLists.txt :52 

add_custom_command ( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/Periodic_3_triangulation_3.qhc
      DEPENDS Periodic_3_triangulation_3.qhp Periodic_3_triangulation_3.qhcp
      COMMAND Qt5::qcollectiongenerator
                 ${CMAKE_CURRENT_SOURCE_DIR}/Periodic_3_triangulation_3.qhcp
                 -o ${CMAKE_CURRENT_BINARY_DIR}/Periodic_3_triangulation_3.qhc
  )

NGSolve/ngsolve basiclinalg/CMakeLists.txt :14 

add_custom_command(OUTPUT  matkernel_1.hpp matkernel_2.hpp matkernel_4.hpp matkernel_8.hpp
  COMMAND ${kernel_command} matkernel_1.hpp 1
  COMMAND ${kernel_command} matkernel_2.hpp 2
  COMMAND ${kernel_command} matkernel_4.hpp 4
  COMMAND ${kernel_command} matkernel_8.hpp 8
  DEPENDS kernel_generator
)

wpilibsuite/allwpilib thirdparty/imgui_suite/glfw/src/CMakeLists.txt :87 

add_custom_command(OUTPUT "${output_file}-code.h"
            COMMAND "${WAYLAND_SCANNER_EXECUTABLE}" private-code "${protocol_file}" "${output_file}-code.h"
            DEPENDS "${protocol_file}"
            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")

rheit/zdoom CMakeLists.txt :61 

add_custom_command( OUTPUT ${ZDOOM_OUTPUT_DIR}/${PK3_NAME}
			COMMAND zipdir -udf ${ZDOOM_OUTPUT_DIR}/${PK3_NAME} ${PK3_DIR}
			COMMAND ${CMAKE_COMMAND} -E copy_if_different ${ZDOOM_OUTPUT_DIR}/${PK3_NAME} $<TARGET_FILE_DIR:zdoom>/${PK3_NAME}
			DEPENDS zipdir )

bareos/bareos docs/manuals/CMakeLists.txt :65 

add_custom_command(
    OUTPUT
      ${PROJECT_SOURCE_DIR}/source/include/autogenerated/bareos-sd-config-schema.json
    COMMAND bareos-sd --xs >/dev/null
    COMMAND
      bareos-sd --xs
      >${PROJECT_SOURCE_DIR}/source/include/autogenerated/bareos-sd-config-schema.json
    COMMAND
      sed --in-place --expression="/\\\"version\\\":/d"
      ${PROJECT_SOURCE_DIR}/source/include/autogenerated/bareos-sd-config-schema.json
    DEPENDS bareos-sd
  )

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

CroatiaControlLtd/asterix src/asterix/wireshark-plugin/1.10.6/CMakeLists.txt :584 

ADD_CUSTOM_COMMAND(
        OUTPUT version.h
        COMMAND ${PERL_EXECUTABLE}
        ${CMAKE_CURRENT_SOURCE_DIR}/make-version.pl
        ${CMAKE_CURRENT_SOURCE_DIR}
        DEPENDS
        ${CMAKE_CURRENT_SOURCE_DIR}/make-version.pl
)

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

PrismLauncher/PrismLauncher program_info/CMakeLists.txt :78 

add_custom_command(
        DEPENDS "${in_scd}"
        OUTPUT "${out_man}"
        COMMAND ${SCDOC_SCDOC} < "${in_scd}" > "${out_man}"
    )

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 )

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)

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

openthread/openthread third_party/mbedtls/repo/library/CMakeLists.txt :164 

add_custom_command(
        OUTPUT
            ${CMAKE_CURRENT_BINARY_DIR}/ssl_debug_helpers_generated.c
        COMMAND
            ${MBEDTLS_PYTHON_EXECUTABLE}
                ${CMAKE_CURRENT_SOURCE_DIR}/../scripts/generate_ssl_debug_helpers.py
                --mbedtls-root ${CMAKE_CURRENT_SOURCE_DIR}/..
                ${CMAKE_CURRENT_BINARY_DIR}
        DEPENDS
            ${CMAKE_CURRENT_SOURCE_DIR}/../scripts/generate_ssl_debug_helpers.py
            ${error_headers}
    )

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/3rdparty/libjpeg-turbo/src/simd/CMakeLists.txt :186 

add_custom_command(OUTPUT ${SIMD_OBJ} DEPENDS ${file} ${OBJECT_DEPENDS}
      COMMAND ${CMAKE_ASM_NASM_COMPILER} -f${CMAKE_ASM_NASM_OBJECT_FORMAT}
        ${CMAKE_ASM_NASM_FLAGS} ${CMAKE_CURRENT_SOURCE_DIR}/${file}
        -o${SIMD_OBJ})

ossia/score src/plugins/score-plugin-avnd/CMakeLists.txt :408 

add_custom_command(
      OUTPUT "${AVND_REFLECTION_HELPERS}"
      COMMAND avnd_source_parser "${AVND_QUALIFIED}" "${AVND_MAIN_FILE}" "${AVND_REFLECTION_HELPERS}"
      DEPENDS avnd_source_parser
    )

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

OpenKneeboard/OpenKneeboard src/shaders/CMakeLists.txt :8 

add_custom_command(
        OUTPUT "${SHADER_OUTPUT}"
        DEPENDS "${SOURCE}"
        COMMAND
        "${COMPILER}"
        "$<$<CONFIG:Debug>:-O0>"
        "$<$<CONFIG:Debug>:-Zi>"
        -Fh "${SHADER_OUTPUT}"
        -E ${ENTRYPOINT}
        "${CMAKE_CURRENT_SOURCE_DIR}/${SOURCE}"
        ${ARGN}
    )

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)

hiramvillarreal/iotpos iotstock/src/CMakeLists.txt :65 

ADD_CUSTOM_COMMAND(TARGET translations
                        COMMAND ${GETTEXT_MSGFMT_EXECUTABLE} -o ${_gmoFile} ${_poFile}
                        DEPENDS ${_poFile})

luajit-remake/luajit-remake annotated/bytecodes/CMakeLists.txt :192 

add_custom_command(
  OUTPUT ${post_process_cpp}
  OUTPUT ${dfg_jit_builtin_node_codegen_info_hdr}
  OUTPUT ${post_process_json}
  OUTPUT ${dfg_jit_builtin_node_code_generator_asm}
  COMMAND ${fps_exec} --process-dfg-jit-builtin-nodes --ir-input=$<TARGET_OBJECTS:guest_lang_typecheck_impl_info> --hdr-output=${dfg_jit_builtin_node_codegen_info_hdr} --cpp-output=${post_process_cpp} --json-output=${post_process_json} --asm-output=${dfg_jit_builtin_node_code_generator_asm} --audit-dir=${GENERATED_FILES_DIR}/../audit 
  DEPENDS fps $<TARGET_OBJECTS:guest_lang_typecheck_impl_info>
)

IBAMR/IBAMR CMakeLists.txt :1212 

ADD_CUSTOM_COMMAND(
    OUTPUT ${_output}
    DEPENDS ${_dependencies}
    COMMAND m4 ${_args} ${_input} > ${_output}
    VERBATIM)

AcademySoftwareFoundation/MaterialX libraries/CMakeLists.txt :21 

add_custom_command(
                OUTPUT ${DEST_FILEPATH}
                COMMAND ${CMAKE_COMMAND} -E copy_if_different ${SOURCE_FILEPATH} ${DEST_FILEPATH}
                DEPENDS ${SOURCE_FILEPATH})

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

danmar/cppcheck lib/CMakeLists.txt :16 

add_custom_command(
        OUTPUT ${outfile}
        COMMAND ${Python_EXECUTABLE} "${PROJECT_SOURCE_DIR}/tools/matchcompiler.py"
                --read-dir="${CMAKE_CURRENT_SOURCE_DIR}" 
                --prefix="mc_" 
                --line 
                ${verify_option} 
                ${file}
        DEPENDS ${file} 
        DEPENDS ${PROJECT_SOURCE_DIR}/tools/matchcompiler.py
    )

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

ukoethe/vigra vigranumpy/test/CMakeLists.txt :26 

add_custom_command(
    OUTPUT ${TEST_SUCCESS_FILE}
    DEPENDS ${TEST_SCRIPTS} ${VIGRANUMPY_DEPENDS}
    COMMAND ${CMAKE_COMMAND}
    ARGS -E touch ${TEST_SUCCESS_FILE})

zeek/zeek src/CMakeLists.txt :29 

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

in-formant/in-formant cmake_support/ShaderTarget.cmake :91 

add_custom_command(
        TARGET ${SOURCE_TARGET_NAME}
        POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E remove_directory "$<TARGET_FILE_DIR:${SOURCE_TARGET_NAME}>/shaders/${output_subdir}"
        COMMAND ${CMAKE_COMMAND} -E make_directory "$<TARGET_FILE_DIR:${SOURCE_TARGET_NAME}>/shaders/${output_subdir}"
        COMMAND ${CMAKE_COMMAND} -E copy_directory "${output_dir}" "$<TARGET_FILE_DIR:${SOURCE_TARGET_NAME}>/shaders/${output_subdir}"
        DEPENDS ${GLSL_SOURCE_FILES}
    )

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

BRAINSia/BRAINSTools ReferenceAtlas/CMakeLists.txt :45 

add_custom_command(
        OUTPUT ${INSTDEST}/${${ThisImageVarName}_VAR_BASENAME}
        COMMAND ${CMAKE_COMMAND} ARGS -E copy ${${ThisImageVarName}_VAR} ${INSTDEST}/${${ThisImageVarName}_VAR_BASENAME}
        DEPENDS ${${ThisImageVarName}_VAR_REALPATH}
        )

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)

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

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 :16 

add_custom_command(
  OUTPUT ${CEPH_NODE_PROXY_VIRTUALENV}/bin/ceph-node-proxy
  DEPENDS ${CEPH_NODE_PROXY_VIRTUALENV}/bin/python
  COMMAND . ${CEPH_NODE_PROXY_VIRTUALENV}/bin/activate && ${CEPH_NODE_PROXY_VIRTUALENV}/bin/python setup.py develop && deactivate
  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/src/ceph-node-proxy
  COMMENT "${CMAKE_SOURCE_DIR}/src/ceph-node-proxy")

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 java/CMakeLists.txt :134 

add_custom_command(OUTPUT ${BINDIR}/${CLASSPATH}/${icon}
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
      ${SRCDIR}/${CLASSPATH}/${icon} ${BINDIR}/${CLASSPATH}/${icon}
    DEPENDS ${SRCDIR}/${CLASSPATH}/${icon})

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 openvdb_houdini/openvdb_houdini/abitest/CMakeLists.txt :58 

add_custom_command(
  OUTPUT ${PROJECT_BINARY_DIR}/TestABIHoudini.cc
  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/TestABI.cc
  COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_SOURCE_DIR}/TestABI.cc ${PROJECT_BINARY_DIR}/TestABIHoudini.cc
)

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
    )

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

STEllAR-GROUP/hpx tests/performance/network/network_storage/CMakeLists.txt :88 

add_custom_command(
      OUTPUT "${HPX_WITH_BENCHMARK_SCRIPTS_PATH}/${script}.sh"
      COMMAND
        "${CMAKE_COMMAND}" ARGS -DEXE_PATH="$<TARGET_FILE:network_storage>"
        -DMPIEXEC="${MPIEXEC}" -DSCRIPT_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}"
        -DSCRIPT_NAME=${script}
        -DSCRIPT_DEST_DIR="${HPX_WITH_BENCHMARK_SCRIPTS_PATH}"
        -DLIB_PATH="${LD_LIBRARY_PATH}" -DJOB_OPTIONS1="${SLURM_JOB_OPTIONS1}"
        -P "${CMAKE_CURRENT_SOURCE_DIR}/copy_script.cmake"
      DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${script}.sh.in"
      VERBATIM
    )

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

mull-project/mull cmake/fixtures.cmake :33 

add_custom_command(
    OUTPUT ${fixture}
    COMMAND ${MULL_CC} ${SYSROOT} ${local_FLAGS} ${local_INPUT} -o ${fixture}
    DEPENDS ${local_INPUT})

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
		)