cmake examples

liballeg/allegro5 docs/Refman.cmake :474

add_custom_command(
    OUTPUT tags
    DEPENDS ${PAGES_TXT}
    COMMAND ${CTAGS}
        --langdef=allegrodoc
        --langmap=allegrodoc:.txt
        "--regex-allegrodoc=/^#+ API: (.+)/\\1/"
        ${PAGES_TXT}
    VERBATIM
    )

assimp/assimp CMakeLists.txt :915

ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Release/assimp-${ASSIMP_MSVC_VERSION}-mt.dll	${BIN_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.dll VERBATIM)

assimp/assimp CMakeLists.txt :920

ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Debug/assimp-${ASSIMP_MSVC_VERSION}-mtd.ilk		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.ilk VERBATIM)

assimp/assimp CMakeLists.txt :924

ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mt.dll	${BIN_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.dll VERBATIM)

assimp/assimp CMakeLists.txt :926

ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mt.lib	${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.lib VERBATIM)

assimp/assimp CMakeLists.txt :927

ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mtd.dll		${BIN_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.dll  VERBATIM)

assimp/assimp CMakeLists.txt :928

ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mtd.exp		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.exp VERBATIM)

assimp/assimp CMakeLists.txt :930

ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mtd.lib		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.lib VERBATIM)

assimp/assimp CMakeLists.txt :931

ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb VERBATIM)

assimp/assimp contrib/draco/cmake/draco_emscripten.cmake :130

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)

avrdudes/avrdude src/doc/CMakeLists.txt :64

add_custom_command(
    OUTPUT programmer_types.texi
    DEPENDS programmer_types.txt
    COMMAND ${CMAKE_COMMAND}
        -D TXT_FILE=programmer_types.txt
        -D TEXI_FILE=programmer_types.texi
        -P "${CMAKE_CURRENT_SOURCE_DIR}/programmer_types.cmake"
    VERBATIM
    )

avrdudes/avrdude src/doc/CMakeLists.txt :83

add_custom_command(
    OUTPUT avrstats.texi
    DEPENDS avrdude_binaries
    COMMAND echo -n "@set NUMPARTS " >> avrstats.texi
    COMMAND $<TARGET_FILE:avrdude> -C ${AVRDUDE_CONF} -p \? 2>&1 | grep = | wc -l >> avrstats.texi
    COMMAND echo -n "@set NUMPROGRAMMERS " >> avrstats.texi
    COMMAND $<TARGET_FILE:avrdude> -C ${AVRDUDE_CONF} -c \? 2>&1 | grep = | wc -l >> avrstats.texi
    VERBATIM
    )

capnproto/capnproto c++/cmake/CapnProtoMacros.cmake :106

add_custom_command(
  OUTPUT "${output_base}.c++" "${output_base}.h"
  COMMAND "${CAPNP_EXECUTABLE}"
  ARGS compile
      -o ${CAPNPC_CXX_EXECUTABLE}${output_dir}
      --src-prefix ${CAPNPC_SRC_PREFIX}
      ${include_path}
      ${CAPNPC_FLAGS}
      ${file_path}
  DEPENDS "${schema_file}" ${tool_depends}
  COMMENT "Compiling Cap'n Proto schema ${schema_file}"
  VERBATIM
)

catchorg/Catch2 extras/Catch.cmake :212

add_custom_command(
  TARGET ${TARGET} POST_BUILD
  BYPRODUCTS "${ctest_tests_file}"
  COMMAND "${CMAKE_COMMAND}"
          -D "TEST_TARGET=${TARGET}"
          -D "TEST_EXECUTABLE=$<TARGET_FILE:${TARGET}>"
          -D "TEST_EXECUTOR=${crosscompiling_emulator}"
          -D "TEST_WORKING_DIR=${_WORKING_DIRECTORY}"
          -D "TEST_SPEC=${_TEST_SPEC}"
          -D "TEST_EXTRA_ARGS=${_EXTRA_ARGS}"
          -D "TEST_PROPERTIES=${_PROPERTIES}"
          -D "TEST_PREFIX=${_TEST_PREFIX}"
          -D "TEST_SUFFIX=${_TEST_SUFFIX}"
          -D "TEST_LIST=${_TEST_LIST}"
          -D "TEST_REPORTER=${_REPORTER}"
          -D "TEST_OUTPUT_DIR=${_OUTPUT_DIR}"
          -D "TEST_OUTPUT_PREFIX=${_OUTPUT_PREFIX}"
          -D "TEST_OUTPUT_SUFFIX=${_OUTPUT_SUFFIX}"
          -D "TEST_DL_PATHS=${_DL_PATHS}"
          -D "TEST_DL_FRAMEWORK_PATHS=${_DL_FRAMEWORK_PATHS}"
          -D "CTEST_FILE=${ctest_tests_file}"
          -D "ADD_TAGS_AS_LABELS=${_ADD_TAGS_AS_LABELS}"
          -P "${_CATCH_DISCOVER_TESTS_SCRIPT}"
  VERBATIM
)

catchorg/Catch2 extras/CatchShardTests.cmake :51

add_custom_command(
  TARGET ${TARGET} POST_BUILD
  BYPRODUCTS "${ctest_tests_file}"
  COMMAND "${CMAKE_COMMAND}"
          -D "TARGET_NAME=${TARGET}"
          -D "TEST_BINARY=$<TARGET_FILE:${TARGET}>"
          -D "CTEST_FILE=${ctest_tests_file}"
          -D "SHARD_COUNT=${_SHARD_COUNT}"
          -D "REPORTER_SPEC=${_REPORTER}"
          -D "TEST_SPEC=${_TEST_SPEC}"
          -P "${shard_impl_script_file}"
  VERBATIM
)

CLIUtils/CLI11 tests/CMakeLists.txt :113

add_custom_command(
  OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${DATA_FILE}"
  COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/${DATA_FILE}"
          "${CMAKE_CURRENT_BINARY_DIR}/${DATA_FILE}"
  MAIN_DEPENDENCY "${CMAKE_CURRENT_SOURCE_DIR}/${DATA_FILE}"
  VERBATIM)

mono/corefx src/Native/Unix/CMakeLists.txt :220

add_custom_command(
    TARGET ${targetName}
    POST_BUILD
    VERBATIM 
    COMMAND ${OBJCOPY} --only-keep-debug ${strip_source_file} ${strip_destination_file}
    COMMAND ${OBJCOPY} --strip-unneeded ${strip_source_file}
    COMMAND ${OBJCOPY} --add-gnu-debuglink=${strip_destination_file} ${strip_source_file}
    COMMENT Stripping symbols from ${strip_source_file} into file ${strip_destination_file}
)

mono/corefx src/Native/Unix/System.Security.Cryptography.Native/CMakeLists.txt :78

add_custom_command(TARGET System.Security.Cryptography.Native.OpenSsl POST_BUILD
    COMMENT "Verifying System.Security.Cryptography.Native.OpenSsl.so dependencies"
    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/../verify-so.sh 
        $<TARGET_FILE:System.Security.Cryptography.Native.OpenSsl> 
        "Verification failed. System.Security.Cryptography.Native.OpenSsl.so has undefined dependencies. These are likely OpenSSL APIs that need to be added to opensslshim.h"
    VERBATIM
)

cpputest/cpputest cmake/Modules/CppUTest.cmake :79

add_custom_command(
    TARGET ${target} POST_BUILD
    BYPRODUCTS "${CTEST_GENERATED_FILE}"
    COMMAND
        "${CMAKE_COMMAND}"
        -D "TESTS_DETAILED:BOOL=${_DETAILED}"
        -D "EXECUTABLE=$<TARGET_FILE:${target}>"
        -D "EMULATOR=${emulator}"
        -D "ARGS=${_EXTRA_ARGS}"
        -D "CTEST_FILE=${CTEST_GENERATED_FILE}"
        -P "${_CPPUTEST_DISCOVERY_SCRIPT}"
    WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
    VERBATIM
)

curl/curl docs/CMakeLists.txt :35

add_custom_command(OUTPUT "${_man_target}"
  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
  COMMAND "${PERL_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/scripts/cd2nroff" "${_man_misc}.md" > "${_man_target}"
  DEPENDS "${PROJECT_SOURCE_DIR}/scripts/cd2nroff" "${_man_misc}.md"
  VERBATIM
)

curl/curl docs/cmdline-opts/CMakeLists.txt :28

add_custom_command(OUTPUT "${CURL_MANPAGE}" "${CURL_ASCIIPAGE}"
  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
  COMMAND "${PERL_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/scripts/managen" mainpage ${DPAGES} > "${CURL_MANPAGE}"
  COMMAND "${PERL_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/scripts/managen" ascii ${DPAGES} > "${CURL_ASCIIPAGE}"
  DEPENDS "${PROJECT_SOURCE_DIR}/scripts/managen" ${DPAGES}
  VERBATIM
)

curl/curl docs/libcurl/CMakeLists.txt :43

add_custom_command(OUTPUT ${_rofffiles}
  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
  COMMAND "${PERL_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/scripts/cd2nroff" -k -d "${CMAKE_CURRENT_BINARY_DIR}" ${_mdfiles}
  DEPENDS "${PROJECT_SOURCE_DIR}/scripts/cd2nroff" ${_mdfiles}
  VERBATIM
)

curl/curl docs/libcurl/CMakeLists.txt :67

add_custom_command(OUTPUT "libcurl-symbols.md"
  COMMAND
    "${PERL_EXECUTABLE}"
    "${CMAKE_CURRENT_SOURCE_DIR}/mksymbolsmanpage.pl" <
    "${CMAKE_CURRENT_SOURCE_DIR}/symbols-in-versions" > "libcurl-symbols.md"
  DEPENDS
    "${CMAKE_CURRENT_SOURCE_DIR}/mksymbolsmanpage.pl"
    "${CMAKE_CURRENT_SOURCE_DIR}/symbols-in-versions"
  VERBATIM
)

curl/curl scripts/CMakeLists.txt :44

add_custom_command(OUTPUT "${_completion_zsh}"
  COMMAND "${PERL_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/completion.pl"
    --opts-dir "${PROJECT_SOURCE_DIR}/docs/cmdline-opts" --shell zsh > "${_completion_zsh}"
  DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/completion.pl"
  VERBATIM
)

curl/curl tests/server/CMakeLists.txt :34

add_custom_command(
  OUTPUT "server_bundle.c"
  COMMAND ${PERL_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/mk-bundle.pl" ${SERVERPROGS} > "server_bundle.c"
  DEPENDS
    "${CMAKE_CURRENT_SOURCE_DIR}/mk-bundle.pl" ${FIRSTFILES}
    "${CMAKE_CURRENT_SOURCE_DIR}/Makefile.inc"
  VERBATIM)

curl/curl tests/unit/CMakeLists.txt :30

add_custom_command(
  OUTPUT "unit_bundle.c"
  COMMAND ${PERL_EXECUTABLE} "${PROJECT_SOURCE_DIR}/tests/mk-bundle.pl" "${CMAKE_CURRENT_SOURCE_DIR}" > "unit_bundle.c"
  DEPENDS
    "${PROJECT_SOURCE_DIR}/tests/mk-bundle.pl" ${FIRSTFILES}
    "${CMAKE_CURRENT_SOURCE_DIR}/Makefile.inc"
  VERBATIM)

cp2k/dbcsr cmake/fypp-sources.cmake :57

add_custom_command(
  OUTPUT "${of}"
  COMMAND ${Python_EXECUTABLE} ${FYPP_EXECUTABLE} ARGS ${fypp_flags}
          "${f}" "${of}"
  MAIN_DEPENDENCY "${f}"
  VERBATIM)

doctest/doctest scripts/cmake/doctest.cmake :135

add_custom_command(
  TARGET ${TARGET} POST_BUILD
  BYPRODUCTS "${ctest_tests_file}"
  COMMAND "${CMAKE_COMMAND}"
          -D "TEST_TARGET=${TARGET}"
          -D "TEST_EXECUTABLE=$<TARGET_FILE:${TARGET}>"
          -D "TEST_EXECUTOR=${crosscompiling_emulator}"
          -D "TEST_WORKING_DIR=${_WORKING_DIRECTORY}"
          -D "TEST_SPEC=${_TEST_SPEC}"
          -D "TEST_EXTRA_ARGS=${_EXTRA_ARGS}"
          -D "TEST_PROPERTIES=${_PROPERTIES}"
          -D "TEST_ADD_LABELS=${_ADD_LABELS}"
          -D "TEST_PREFIX=${_TEST_PREFIX}"
          -D "TEST_SUFFIX=${_TEST_SUFFIX}"
          -D "TEST_LIST=${_TEST_LIST}"
          -D "TEST_JUNIT_OUTPUT_DIR=${_JUNIT_OUTPUT_DIR}"
          -D "CTEST_FILE=${ctest_tests_file}"
          -P "${_DOCTEST_DISCOVER_TESTS_SCRIPT}"
  VERBATIM
)

google/draco cmake/draco_emscripten.cmake :130

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)

jrfonseca/drmingw src/mgwhelp/CMakeLists.txt :40

add_custom_command (
    TARGET mgwhelp
    POST_BUILD
    COMMAND ${CMAKE_COMMAND} -DCMAKE_OBJDUMP=${CMAKE_OBJDUMP} -DTARGET=$<TARGET_FILE:mgwhelp> -P ${CMAKE_SOURCE_DIR}/cmake/CheckDependencies.cmake
    VERBATIM
)

jrfonseca/drmingw tests/CMakeLists.txt :65

add_custom_command (
    OUTPUT ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/.debug/test_mgwhelp_split_subdir.debug
    COMMAND ${CMAKE_OBJCOPY} --only-keep-debug $<TARGET_FILE:test_mgwhelp> ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/.debug/test_mgwhelp_split_subdir.debug
    WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
    DEPENDS test_mgwhelp ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/.debug
    VERBATIM
)

jrfonseca/drmingw tests/CMakeLists.txt :72

add_custom_command (
    OUTPUT ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_mgwhelp_split_subdir.exe
    COMMAND ${CMAKE_OBJCOPY} --strip-all $<TARGET_FILE:test_mgwhelp> --add-gnu-debuglink=test_mgwhelp_split_subdir.debug ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_mgwhelp_split_subdir.exe
    WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/.debug
    DEPENDS ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/.debug/test_mgwhelp_split_subdir.debug
    VERBATIM
)

jrfonseca/drmingw tests/CMakeLists.txt :125

add_custom_command (
    OUTPUT ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_mgwhelp_zdebug.exe
    COMMAND ${CMAKE_OBJCOPY} --strip-all $<TARGET_FILE:test_mgwhelp> --add-gnu-debuglink=test_mgwhelp_zdebug.debug ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_mgwhelp_zdebug.exe
    WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
    DEPENDS ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_mgwhelp_zdebug.debug
    VERBATIM
)

JPeterMugaas/efxc2 build/PVS-Studio.cmake :222

add_custom_command(OUTPUT "${LOG}"
                   COMMAND "${CMAKE_COMMAND}" -E make_directory "${PARENT_DIR}"
                   COMMAND "${CMAKE_COMMAND}" -E remove_directory "${LOG}"
                   COMMAND ${pvscmd}
                   WORKING_DIRECTORY "${BINARY_DIR}"
                   DEPENDS "${SOURCE}" "${PVS_STUDIO_SUPPRESS_BASE}" "${PVS_STUDIO_DEPENDS}"
                   IMPLICIT_DEPENDS "${PVS_STUDIO_LANGUAGE}" "${SOURCE}"
                   ${depCommandArg}
                   VERBATIM
                   COMMENT "Analyzing ${PVS_STUDIO_LANGUAGE} file ${SOURCE_RELATIVE}")

FirebirdSQL/firebird src/CMakeLists.txt :238

add_custom_command(
    OUTPUT y_tab.h y_tab.c
    DEPENDS
        btyacc
        ${parse_src}
    COMMAND sed -n "/%type .*/p" ${CMAKE_CURRENT_SOURCE_DIR}/dsql/parse.y > types.y
    COMMAND sed "s/%type .*//" ${CMAKE_CURRENT_SOURCE_DIR}/dsql/parse.y > y.y
    COMMAND btyacc -l -d -S ${CMAKE_CURRENT_SOURCE_DIR}/dsql/btyacc_fb.ske y.y

    COMMAND sed -i "s/#define \\([A-Z].*\\)/#define TOK_\\1/g" y_tab.h
    COMMAND sed -i "s/#define TOK_YY\\(.*\\)/#define YY\\1/g" y_tab.h

    COMMAND ${CMAKE_COMMAND} -E copy_if_different y_tab.h include/gen/parse.h
    COMMAND ${CMAKE_COMMAND} -E copy_if_different y_tab.c dsql/parse.cpp
    COMMENT "Generating parse.cpp, parse.h"
    VERBATIM
)

fltk/fltk CMake/fl_create_example.cmake :151

add_custom_command(
  TARGET ${TARGET_NAME} POST_BUILD
  COMMAND cp ${FLTK_SOURCE_DIR}/CMake/macOS-bundle-wrapper.in ${WRAPPER}
  COMMAND chmod u+x,g+x,o+x ${WRAPPER}
  BYPRODUCTS ${WRAPPER}
  # COMMENT "Creating macOS bundle wrapper script ${WRAPPER}"
  VERBATIM
)

fltk/fltk documentation/CMakeLists.txt :120

add_custom_command(
  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${DOXYFILE}
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/convert_doxyfile
          ${DOXYGEN_EXECUTABLE}
          ${DOXYFILE}.in
          ${DOXYFILE}
          ${LOGFILE}
  BYPRODUCTS ${LOGFILE}
  COMMENT "Converting ${DOXYFILE} to doxygen version ${DOXYGEN_VERSION_SHORT}" VERBATIM
)

fltk/fltk documentation/CMakeLists.txt :175

add_custom_command(
  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${DOXYFILE}
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/convert_doxyfile
          ${DOXYGEN_EXECUTABLE}
          ${DOXYFILE}.in
          ${DOXYFILE}
          ${LOGFILE}
  BYPRODUCTS ${LOGFILE}
  COMMENT "Converting ${DOXYFILE} to doxygen version ${DOXYGEN_VERSION_SHORT}" VERBATIM
)

fltk/fltk documentation/CMakeLists.txt :203

add_custom_command(
  OUTPUT  ${CMAKE_CURRENT_BINARY_DIR}/fltk.pdf
  COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/make_header
          ${DOXYGEN_EXECUTABLE}
          ${CMAKE_CURRENT_BINARY_DIR}/fltk-title.tex
          ${CMAKE_CURRENT_BINARY_DIR}/fltk-book.tex
  COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYFILE}
  COMMAND ${CMAKE_CURRENT_BINARY_DIR}/make_pdf
  COMMAND cp -f latex/refman.pdf fltk.pdf
  DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${DOXYFILE}
          ${CMAKE_CURRENT_BINARY_DIR}/fltk-title.tex
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  COMMENT "Generating PDF documentation" VERBATIM
)

fltk/fltk fltk-options/CMakeLists.txt :69

add_custom_command(
  TARGET ${TARGET} POST_BUILD
  COMMAND cp ${FLTK_SOURCE_DIR}/CMake/macOS-bundle-wrapper.in ${WRAPPER}
  COMMAND chmod u+x,g+x,o+x ${WRAPPER}
  BYPRODUCTS ${WRAPPER}
  VERBATIM
)

fltk/fltk fluid/CMakeLists.txt :77

add_custom_command(
  TARGET ${TARGET} POST_BUILD
  COMMAND cp ${FLTK_SOURCE_DIR}/CMake/macOS-bundle-wrapper.in ${WRAPPER}
  COMMAND chmod u+x,g+x,o+x ${WRAPPER}
  BYPRODUCTS ${WRAPPER}
  VERBATIM
)

fltk/fltk fluid/documentation/CMakeLists.txt :100

add_custom_command(
  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${DOXYFILE}
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/convert_doxyfile
          ${DOXYGEN_EXECUTABLE}
          ${DOXYFILE}.in
          ${DOXYFILE}
          ${LOGFILE}
  BYPRODUCTS ${LOGFILE}
  COMMENT "Converting ${DOXYFILE} to doxygen version ${DOXYGEN_VERSION_SHORT}" VERBATIM
)

fltk/fltk fluid/documentation/CMakeLists.txt :154

add_custom_command(
  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${DOXYFILE}
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/convert_doxyfile
          ${DOXYGEN_EXECUTABLE}
          ${DOXYFILE}.in
          ${DOXYFILE}
          ${LOGFILE}
  BYPRODUCTS ${LOGFILE}
  COMMENT "Converting ${DOXYFILE} to doxygen version ${DOXYGEN_VERSION_SHORT}" VERBATIM
)

fltk/fltk src/CMakeLists.txt :788

add_custom_command(
  OUTPUT text-input-protocol.c text-input-client-protocol.h
  COMMAND wayland-scanner private-code  ${INFILE} text-input-protocol.c
  COMMAND wayland-scanner client-header ${INFILE} text-input-client-protocol.h
  DEPENDS ${INFILE}
  VERBATIM
)

facebook/folly build/fbcode_builder/CMake/FBPythonBinary.cmake :302

add_custom_command(
  TARGET "${TARGET}.GEN_PY_EXE" POST_BUILD
  BYPRODUCTS "${ctest_tests_file}"
  COMMAND
    "${CMAKE_COMMAND}"
    -D "TEST_TARGET=${TARGET}"
    -D "TEST_INTERPRETER=${Python3_EXECUTABLE}"
    -D "TEST_ENV=${ARG_ENV}"
    -D "TEST_EXECUTABLE=$<TARGET_PROPERTY:${TARGET}.GEN_PY_EXE,EXECUTABLE>"
    -D "TEST_WORKING_DIR=${ARG_WORKING_DIRECTORY}"
    -D "TEST_LIST=${ARG_TEST_LIST}"
    -D "TEST_PREFIX=${TARGET}::"
    -D "TEST_PROPERTIES=${ARG_PROPERTIES}"
    -D "CTEST_FILE=${ctest_tests_file}"
    -P "${FB_PY_TEST_DISCOVER_SCRIPT}"
  VERBATIM
)

fontforge/fontforge po/CMakeLists.txt :41

add_custom_command(OUTPUT "${_full}"
  COMMAND "${CMAKE_COMMAND}" -E make_directory "${CMAKE_CURRENT_BINARY_DIR}/full"
  COMMAND "${GETTEXT_MSGMERGE_EXECUTABLE}" -N "${_input}" -F "${CMAKE_CURRENT_BINARY_DIR}/FontForge.pot" -o "${_full}"
  DEPENDS "${_input}" potfiles
  VERBATIM
)

pietrodelugas/fox dom/CMakeLists.txt :14

ADD_CUSTOM_COMMAND(
  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/m_dom_extras.F90
  COMMAND ${M4_PROGRAM} -I ../m4 ${CMAKE_CURRENT_SOURCE_DIR}/m_dom_extras.m4 > ${CMAKE_CURRENT_BINARY_DIR}/m_dom_extras.F90
  DEPENDS m_dom_extras.m4
  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
  VERBATIM
)

pietrodelugas/fox dom/CMakeLists.txt :24

ADD_CUSTOM_COMMAND(
  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/m_dom_parse.f90
  COMMAND ${M4_PROGRAM} -I ../m4 ${CMAKE_CURRENT_SOURCE_DIR}/m_dom_parse.m4 > ${CMAKE_CURRENT_BINARY_DIR}/m_dom_parse.f90
  DEPENDS m_dom_parse.m4
  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
  VERBATIM
)

pietrodelugas/fox dom/CMakeLists.txt :34

ADD_CUSTOM_COMMAND(
  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/m_dom_utils.f90
  COMMAND ${M4_PROGRAM} -I ../m4 ${CMAKE_CURRENT_SOURCE_DIR}/m_dom_utils.m4 > ${CMAKE_CURRENT_BINARY_DIR}/m_dom_utils.f90
  DEPENDS m_dom_utils.m4
  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
  VERBATIM
)

pietrodelugas/fox fsys/CMakeLists.txt :4

ADD_CUSTOM_COMMAND(
  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/fox_m_fsys_parse_input.F90
  COMMAND ${M4_PROGRAM} -I ../m4 ${CMAKE_CURRENT_SOURCE_DIR}/fox_m_fsys_parse_input.m4 > ${CMAKE_CURRENT_BINARY_DIR}/fox_m_fsys_parse_input.F90
  DEPENDS fox_m_fsys_parse_input.m4
  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
  VERBATIM
)

pietrodelugas/fox fsys/CMakeLists.txt :12

ADD_CUSTOM_COMMAND(
  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/fox_m_fsys_count_parse_input.F90
  COMMAND ${M4_PROGRAM} -I ../m4 ${CMAKE_CURRENT_SOURCE_DIR}/fox_m_fsys_count_parse_input.m4 > ${CMAKE_CURRENT_BINARY_DIR}/fox_m_fsys_count_parse_input.F90
  DEPENDS fox_m_fsys_count_parse_input.m4
  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
  VERBATIM
)

pietrodelugas/fox wxml/CMakeLists.txt :4

ADD_CUSTOM_COMMAND(
  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/m_wxml_overloads.F90
  COMMAND ${M4_PROGRAM} -I ../m4 ${CMAKE_CURRENT_SOURCE_DIR}/m_wxml_overloads.m4 > ${CMAKE_CURRENT_BINARY_DIR}/m_wxml_overloads.F90
  DEPENDS m_wxml_overloads.m4
  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
  VERBATIM
)

OSGeo/gdal swig/csharp/CMakeLists.txt :237

add_custom_command(
  COMMAND ${CMAKE_COMMAND} -E "copy_if_different"
          "${CMAKE_CURRENT_BINARY_DIR}/${_CSHARP_TARGET_SUBDIR}/${_root}-$<CONFIG>.csproj" "${_CSHARP_PROJ}"
  VERBATIM
  DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${_CSHARP_TARGET_SUBDIR}/${_root}-$<CONFIG>.csproj"
  OUTPUT ${_CSHARP_PROJ})

OSGeo/gdal swig/csharp/CMakeLists.txt :462

add_custom_command(
  OUTPUT ${OUTPUT_FILENAME}
  COMMAND ${CMAKE_COMMAND} -E echo "Building ${_GBCS_OUTPUT_NATIVE}"
  COMMAND ${CSHARP_COMPILER} ${CSC_OPTIONS}
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  VERBATIM
  DEPENDS csharp_binding ${_GBCS_SOURCE})

OSGeo/gdal swig/java/CMakeLists.txt :153

add_custom_command(
  OUTPUT ${JAR_OUTPUT} ${MAVEN_ARTIFACTS}
  COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_CURRENT_BINARY_DIR}/java"
  COMMAND
    ${ANT} ${ANT_TARGET} -f ${CMAKE_CURRENT_SOURCE_DIR}/build.xml ${GPG_KEY_PROPERTY} ${GPG_PASS_PROPERTY}
    -Dskip_make_doc=true -Dbuild_dir=${CMAKE_CURRENT_BINARY_DIR} -Dversion_filename=${PROJECT_SOURCE_DIR}/VERSION
    -Dsource_apps=${CMAKE_CURRENT_SOURCE_DIR}/apps
  VERBATIM
  DEPENDS ${JAVADOC_ZIP} ${GDALALLJNI_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/build.xml ${SOURCE_APPS})

gentoo/gentoo sci-chemistry/openbabel/files/openbabel-python-r2.cmake :11

add_custom_command(
	OUTPUT ${CMAKE_SOURCE_DIR}/scripts/${EPYTHON}/openbabel-python.cpp ${CMAKE_SOURCE_DIR}/scripts/${EPYTHON}/openbabel.py
	COMMAND ${SWIG_EXECUTABLE} -python -c++ -small -O -templatereduce -naturalvar -I${PYTHON_INCLUDE_DIR} -I${CMAKE_SOURCE_DIR}/include -I${CMAKE_BINARY_DIR}/include -o ${CMAKE_SOURCE_DIR}/scripts/${EPYTHON}/openbabel-python.cpp ${eigen_define} -outdir ${CMAKE_SOURCE_DIR}/scripts/${EPYTHON} ${CMAKE_SOURCE_DIR}/scripts/openbabel-python.i
	MAIN_DEPENDENCY openbabel-python.i
	VERBATIM
)

gentoo/gentoo sci-chemistry/openbabel/files/openbabel-python.cmake :13

add_custom_command(
	OUTPUT ${CMAKE_SOURCE_DIR}/scripts/${EPYTHON}/openbabel-python.cpp ${CMAKE_SOURCE_DIR}/scripts/${EPYTHON}/openbabel.py
	COMMAND ${SWIG_EXECUTABLE} -python -c++ -small -O -templatereduce -naturalvar -I${CMAKE_SOURCE_DIR}/include -I${CMAKE_BINARY_DIR}/include -o ${CMAKE_SOURCE_DIR}/scripts/${EPYTHON}/openbabel-python.cpp ${eigen_define} -outdir ${CMAKE_SOURCE_DIR}/scripts/${EPYTHON} ${CMAKE_SOURCE_DIR}/scripts/openbabel-python.i
	MAIN_DEPENDENCY openbabel-python.i
	VERBATIM
)

glfw/glfw docs/CMakeLists.txt :41

add_custom_command(OUTPUT "html/index.html"
                   COMMAND "${DOXYGEN_EXECUTABLE}"
                   WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
                   MAIN_DEPENDENCY Doxyfile
                   DEPENDS ${header_paths} ${source_files} ${extra_files}
                   COMMENT "Generating HTML documentation"
                   VERBATIM)

glfw/glfw src/CMakeLists.txt :86

add_custom_command(OUTPUT ${header_file}
    COMMAND "${WAYLAND_SCANNER_EXECUTABLE}" client-header "${protocol_path}" ${header_file}
    DEPENDS "${protocol_path}"
    VERBATIM)

grpc/grpc CMakeLists.txt :633

add_custom_command(
  OUTPUT "${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}.grpc.pb.cc"
         "${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}.grpc.pb.h"
         "${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}_mock.grpc.pb.h"
         "${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}.pb.cc"
         "${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}.pb.h"
  COMMAND ${_gRPC_PROTOBUF_PROTOC_EXECUTABLE}
  ARGS --grpc_out=generate_mock_code=true:${_gRPC_PROTO_GENS_DIR}
       --cpp_out=${_gRPC_PROTO_GENS_DIR}
       --plugin=protoc-gen-grpc=${_gRPC_CPP_PLUGIN}
       ${_protobuf_include_path}
       ${REL_FIL}
  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${FILE_LOCATION} ${ABS_FIL} ${_gRPC_PROTOBUF_PROTOC} ${_gRPC_CPP_PLUGIN}
  WORKING_DIRECTORY ${_gRPC_PROTO_SRCS_DIR}
  COMMENT "Running gRPC C++ protocol buffer compiler for ${IMPORT_PATH}"
  VERBATIM)

HDFGroup/hdf4 config/cmake/UseJava.cmake :874

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}
        ${_GENERATE_NATIVE_HEADERS}
        ${_JAVA_SOURCES_FILELISTS}
    COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
    DEPENDS ${_JAVA_COMPILE_FILES} ${_JAVA_COMPILE_FILELISTS} ${_JAVA_COMPILE_DEPENDS} ${_JAVA_SOURCES_FILE}
    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
    COMMENT "Building Java objects for ${_TARGET_NAME}.jar"
    VERBATIM
)

HDFGroup/hdf4 config/cmake/UseJava.cmake :889

add_custom_command(
    OUTPUT ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
    COMMAND ${CMAKE_COMMAND}
        -DCMAKE_JAVA_CLASS_OUTPUT_PATH=${CMAKE_JAVA_CLASS_OUTPUT_PATH}
        -DCMAKE_JAR_CLASSES_PREFIX=${CMAKE_JAR_CLASSES_PREFIX}
        -P ${_JAVA_CLASS_FILELIST_SCRIPT}
    DEPENDS ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
    VERBATIM
)

HDFGroup/hdf4 config/cmake/UseJava.cmake :931

add_custom_command(
    OUTPUT ${_JAVA_JAR_OUTPUT_PATH}
    COMMAND ${Java_JAR_EXECUTABLE}
        -cf${_ENTRY_POINT_OPTION}${_MANIFEST_OPTION} ${_JAVA_JAR_OUTPUT_PATH} ${_ENTRY_POINT_VALUE} ${_MANIFEST_VALUE}
        ${_JAVA_RESOURCE_FILES_RELATIVE} @java_class_filelist
    COMMAND ${CMAKE_COMMAND}
        -D_JAVA_TARGET_DIR=${_add_jar_OUTPUT_DIR}
        -D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_TARGET_OUTPUT_NAME}
        -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
        -P ${_JAVA_SYMLINK_SCRIPT}
    WORKING_DIRECTORY ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
    DEPENDS ${_JAVA_RESOURCE_FILES} ${_JAVA_DEPENDS} ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
    COMMENT "Creating Java archive ${_JAVA_TARGET_OUTPUT_NAME}"
    VERBATIM
)

HDFGroup/hdf4 HDF4Examples/config/cmake/UseJava.cmake :889

add_custom_command(
    OUTPUT ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
    COMMAND ${CMAKE_COMMAND}
        -DCMAKE_JAVA_CLASS_OUTPUT_PATH=${CMAKE_JAVA_CLASS_OUTPUT_PATH}
        -DCMAKE_JAR_CLASSES_PREFIX=${CMAKE_JAR_CLASSES_PREFIX}
        -P ${_JAVA_CLASS_FILELIST_SCRIPT}
    DEPENDS ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
    VERBATIM
)

HDFGroup/hdf4 HDF4Examples/config/cmake/UseJava.cmake :931

add_custom_command(
    OUTPUT ${_JAVA_JAR_OUTPUT_PATH}
    COMMAND ${Java_JAR_EXECUTABLE}
        -cf${_ENTRY_POINT_OPTION}${_MANIFEST_OPTION} ${_JAVA_JAR_OUTPUT_PATH} ${_ENTRY_POINT_VALUE} ${_MANIFEST_VALUE}
        ${_JAVA_RESOURCE_FILES_RELATIVE} @java_class_filelist
    COMMAND ${CMAKE_COMMAND}
        -D_JAVA_TARGET_DIR=${_add_jar_OUTPUT_DIR}
        -D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_TARGET_OUTPUT_NAME}
        -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
        -P ${_JAVA_SYMLINK_SCRIPT}
    WORKING_DIRECTORY ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
    DEPENDS ${_JAVA_RESOURCE_FILES} ${_JAVA_DEPENDS} ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
    COMMENT "Creating Java archive ${_JAVA_TARGET_OUTPUT_NAME}"
    VERBATIM
)

igraph/igraph vendor/f2c/CMakeLists.txt :28

add_custom_command(
  OUTPUT arith.h
  COMMENT "Generating arith.h for f2c..."
  COMMAND arithchk > ${CMAKE_CURRENT_BINARY_DIR}/arith.h
  DEPENDS arithchk
  VERBATIM
)

igraph/igraph vendor/f2c/CMakeLists.txt :42

add_custom_command(
  TARGET arithchk POST_BUILD
  COMMENT "Printing contents of arith.h..."
  COMMAND arithchk
  VERBATIM USES_TERMINAL
)

dscharrer/innoextract cmake/VersionString.cmake :108

add_custom_command(
	OUTPUT
		"${abs_dst}"
	COMMAND
		${CMAKE_COMMAND}
		"-DINPUT=${abs_src}"
		"-DOUTPUT=${abs_dst}"
		"-DVERSION_SOURCES=${args}"
		"-DGIT_DIR=${abs_git_dir}"
		"-DGIT_COMMAND=${GIT_COMMAND}"
		${defines}
		-P "${VERSION_STRING_SCRIPT}"
	COMMAND
		${CMAKE_COMMAND} -E touch "${abs_dst}"
	MAIN_DEPENDENCY
		"${abs_src}"
	DEPENDS
		${dependencies}
	COMMENT ""
	VERBATIM
)

ispc/ispc ispcrt/cmake/interop.cmake :132

add_custom_command(
    DEPENDS ${input}
    OUTPUT "${TARGET_OUTPUT_FILE_RESULT}"
    COMMAND ${DPCPP_COMPILER}
        -fsycl
        -fPIE
        ${DPCPP_CXX_FLAGS}
        ${DPCPP_CUSTOM_INCLUDE_DIR_PARMS}
        ${DPCPP_CUSTOM_FLAGS}
        -I ${CMAKE_CURRENT_SOURCE_DIR}
        -o "$<IF:$<BOOL:${DPCPP_SPV}>,${TARGET_OUTPUT_FILE}.bc,${TARGET_OUTPUT_FILE}.o>"
        ${input}

    # Run sycl-post-link on it
    COMMAND
    "$<$<BOOL:${DPCPP_SPV}>:${DPCPP_SYCL_POST_LINK}>"
    "$<$<BOOL:${DPCPP_SPV}>:${SYCL_POST_LINK_ARGS};${TARGET_OUTPUT_FILE}.bc>"
    "$<$<BOOL:${DPCPP_SPV}>:-o;${TARGET_OUTPUT_FILE}.postlink.bc>"

    # And finally back to SPV to the original expected target SPV name
    COMMAND
    "$<$<BOOL:${DPCPP_SPV}>:${DPCPP_LLVM_SPIRV}>"
    # Pick the right input to llvm-spirv based on if we're linking scalar or esimd
    # DPCPP libraries.
    "$<$<BOOL:${DPCPP_SPV}>:${TARGET_OUTPUT_FILE}.postlink_0.bc>"
    "$<$<BOOL:${DPCPP_SPV}>:${DPCPP_LLVM_SPIRV_ARGS}>"
    "$<$<BOOL:${DPCPP_SPV}>:-o;${TARGET_OUTPUT_FILE}.spv>"
    COMMENT "Building DPCPP object ${TARGET_OUTPUT_FILE_RESULT}"
    COMMAND_EXPAND_LISTS
    VERBATIM
)

ispc/ispc ispcrt/cmake/ispc.cmake :243

add_custom_command(
  OUTPUT ${results} ${outdir}/${fname}_ispc.h
  COMMAND ${CMAKE_COMMAND} -E make_directory ${outdir}
  COMMAND ${ISPC_EXECUTABLE}
    ${ISPC_DEFINITIONS}
    -I ${CMAKE_CURRENT_SOURCE_DIR}
    "$<$<BOOL:${ISPC_INCLUDE_DIRS_EXPR}>:-I$<JOIN:${ISPC_INCLUDE_DIRS_EXPR},;-I>>"
    ${ISPC_INCLUDE_DIR_PARMS}
    "$<$<BOOL:${ISPC_COMPILE_DEFINITIONS_EXPR}>:-D$<JOIN:${ISPC_COMPILE_DEFINITIONS_EXPR},;-D>>"
    --arch=${ISPC_ARCHITECTURE}
    --addressing=${ISPC_ADDRESSING}
    ${ISPC_OPT_FLAGS}
    --target=${ISPC_TARGET_ARGS}
    --woff
    ${ISPC_ADDITIONAL_ARGS}
    -h ${outdir}/${fname}_ispc.h
    -MMM ${ISPC_DEPENDENCIES_FILE}
    -o ${outdir}/${fname}.dev${ISPC_TARGET_EXT}
    ${input}
  DEPENDS ${input} ${ISPC_DEPENDENCIES}
  COMMENT "Building ISPC object ${outdir}/${fname}.dev${ISPC_TARGET_EXT}"
  COMMAND_EXPAND_LISTS
  VERBATIM
)

ispc/ispc ispcrt/cmake/ispc.cmake :378

add_custom_command(
  OUTPUT ${result}
  DEPENDS ${input} ${ISPC_DEPENDENCIES}
  COMMAND ${CMAKE_COMMAND} -E make_directory ${outdir}
  COMMAND ${ISPC_EXECUTABLE}
    -I ${CMAKE_CURRENT_SOURCE_DIR}
    "$<$<BOOL:${ISPC_INCLUDE_DIRS_EXPR}>:-I$<JOIN:${ISPC_INCLUDE_DIRS_EXPR},;-I>>"
    ${ISPC_INCLUDE_DIR_PARMS}
    ${ISPC_XE_OPT_FLAGS}
    -DISPC_GPU
    "$<$<BOOL:${ISPC_COMPILE_DEFINITIONS_EXPR}>:-D$<JOIN:${ISPC_COMPILE_DEFINITIONS_EXPR},;-D>>"
    ${ISPC_DEFINITIONS}
    --addressing=64
    --target=${ISPC_TARGET_XE}
    ${ISPC_GPU_OUTPUT_OPT}
    --woff
    ${ISPC_XE_ADDITIONAL_ARGS}
    -o ${result}
    ${input}
    -MMM ${ISPC_DEPENDENCIES_FILE}
  COMMENT "Building ISPC GPU object ${result}"
  COMMAND_EXPAND_LISTS
  VERBATIM
)

ispc/ispc ispcrt/cmake/ispc.cmake :490

add_custom_command(
  DEPENDS
    ${ISPC_XE_COMPILE_OUTPUTS}
    ${LINK_GPU_LIBRARIES_PROP}
    ${LINK_DPCPP_LIBRARIES_PROP}
  OUTPUT ${ISPC_TARGET_DIR}/${PARENT_TARGET_NAME}.${TARGET_OUTPUT_EXT}
  COMMAND
    # True case: we're linking and run ispc link. Args we want separate with a space
    # should be separate with a ; here so when the lists are expanded we get the
    # desired space separate in the command
    # False case: we're just going to copy the file with cmake -E copy
    "$<IF:${NEEDS_ISPC_LINK_EXPR},${ISPC_EXECUTABLE};link,cmake;-E;copy>"

    # True case arguments for ispc link
    "$<${NEEDS_ISPC_LINK_EXPR}:${ISPC_XE_COMPILE_OUTPUTS};${LINK_GPU_LIBRARIES_PROP}>"
    "$<${NEEDS_ISPC_LINK_EXPR}:--emit-spirv>"
    "$<${NEEDS_ISPC_LINK_EXPR}:-o>"
    "$<${NEEDS_ISPC_LINK_EXPR}:${TARGET_OUTPUT_FILE}.spv>"

    # False case arguments for cmake -E copy
    # We also pick between zebin/spv suffixes here, zebin and spv are both valid
    # outputs for single-file targets.
    "$<$<NOT:${NEEDS_ISPC_LINK_EXPR}>:${ISPC_XE_COMPILE_OUTPUTS}>"
    "$<$<NOT:${NEEDS_ISPC_LINK_EXPR}>:${TARGET_OUTPUT_FILE}.${TARGET_OUTPUT_EXT}>"

  # For targets doing DPCPP linking we need to do the dpcpp link step against the
  # extracted DPCPP library bitcode and then translate to the final SPV output target
  # First we link the bitcode extracted from DPCPP using DPCPP LLVM link.
  COMMAND
    "$<${LINKS_DPCPP_LIBS}:${DPCPP_LLVM_LINK}>"
    ${LINK_DPCPP_LIBRARIES_PROP}
    "$<${LINKS_DPCPP_LIBS}:-o;${TARGET_OUTPUT_FILE}.linked.dpcpp.bc>"

  # Now we run SYCL post link if we're linking against a scalar DPCPP library
  # ESIMD linking skips this step
  COMMAND
    "$<${LINKS_DPCPP_SCALAR_LIBS}:${DPCPP_SYCL_POST_LINK};${TARGET_OUTPUT_FILE}.linked.dpcpp.bc>"
    "$<${LINKS_DPCPP_SCALAR_LIBS}:${SYCL_POST_LINK_ARGS}>"
    "$<${LINKS_DPCPP_SCALAR_LIBS}:-o;${TARGET_OUTPUT_FILE}.postlink.bc>"

  # Now link with ISPC bitcode with DPCPP extracted and post-processed bitcode.
  COMMAND
    "$<${LINKS_DPCPP_LIBS}:${DPCPP_LLVM_LINK};${result}>"
    "$<${LINKS_DPCPP_SCALAR_LIBS}:${TARGET_OUTPUT_FILE}.postlink_0.bc>"
    "$<${LINKS_DPCPP_ESIMD_LIBS}:${TARGET_OUTPUT_FILE}.linked.dpcpp.bc>"
    "$<${LINKS_DPCPP_LIBS}:-o;${TARGET_OUTPUT_FILE}.linked.bc>"

  # And finally back to SPV to the original expected target SPV name
  COMMAND
    "$<${LINKS_DPCPP_LIBS}:${DPCPP_LLVM_SPIRV}>"
    # Pick the right input to llvm-spirv based on if we're linking scalar or esimd
    # DPCPP libraries.
    "$<${LINKS_DPCPP_SCALAR_LIBS}:${TARGET_OUTPUT_FILE}.linked.bc>"
    "$<${LINKS_DPCPP_ESIMD_LIBS}:${TARGET_OUTPUT_FILE}.linked.bc>"

    "$<${LINKS_DPCPP_LIBS}:${DPCPP_LLVM_SPIRV_ARGS}>"
    "$<${LINKS_DPCPP_LIBS}:-o;${TARGET_OUTPUT_FILE}.spv>"

  COMMENT "Making ISPC library ${TARGET_OUTPUT_FILE}.${TARGET_OUTPUT_EXT}"
  COMMAND_EXPAND_LISTS
  VERBATIM
)

InsightSoftwareConsortium/ITK CMake/CppcheckTargets.cmake :131

add_custom_command(
  TARGET all_cppcheck
  PRE_BUILD
  COMMAND ${CPPCHECK_EXECUTABLE} ${CPPCHECK_QUIET_ARG} ${CPPCHECK_TEMPLATE_ARG} ${_cppcheck_args}
          ${_cppcheck_compile_args} ${_dir}
  WORKING_DIRECTORY "${_dir}"
  COMMENT "${_name}_cppcheck: Running cppcheck on ${_dir}..."
  VERBATIM)

InsightSoftwareConsortium/ITK CMake/CppcheckTargets.cmake :218

add_custom_command(
  TARGET all_cppcheck
  PRE_BUILD
  COMMAND ${CPPCHECK_EXECUTABLE} ${CPPCHECK_QUIET_ARG} ${CPPCHECK_TEMPLATE_ARG} ${_cppcheck_args}
          ${_cppcheck_compile_args} ${_files}
  WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
  COMMENT "${_targetname}_cppcheck: Running cppcheck on target ${_targetname}..."
  VERBATIM)

InsightSoftwareConsortium/ITK CMake/CppcheckTargets.cmake :289

add_custom_command(
  TARGET all_cppcheck
  PRE_BUILD
  COMMAND ${CPPCHECK_EXECUTABLE} ${CPPCHECK_QUIET_ARG} ${CPPCHECK_TEMPLATE_ARG} ${_cppcheck_args} ${_files}
  WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
  COMMENT "${_name}_cppcheck: Running cppcheck on target ${_name}..."
  VERBATIM)

InsightSoftwareConsortium/ITK Modules/ThirdParty/HDF5/src/itkhdf5/config/cmake/UseJava.cmake :910

add_custom_command(
    OUTPUT ${_JAVA_JAR_OUTPUT_PATH}
    COMMAND ${Java_JAR_EXECUTABLE}
        -cf${_ENTRY_POINT_OPTION}${_MANIFEST_OPTION} ${_JAVA_JAR_OUTPUT_PATH} ${_ENTRY_POINT_VALUE} ${_MANIFEST_VALUE}
        ${_JAVA_RESOURCE_FILES_RELATIVE} @java_class_filelist
    COMMAND ${CMAKE_COMMAND}
        -D_JAVA_TARGET_DIR=${_add_jar_OUTPUT_DIR}
        -D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_TARGET_OUTPUT_NAME}
        -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
        -P ${_JAVA_SYMLINK_SCRIPT}
    COMMAND ${CMAKE_COMMAND}
        -D_JAVA_TARGET_DIR=${_add_jar_OUTPUT_DIR}
        -D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_JAR_OUTPUT_PATH}
        -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
        -P ${_JAVA_SYMLINK_SCRIPT}
    DEPENDS ${_JAVA_RESOURCE_FILES} ${_JAVA_DEPENDS} ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
    WORKING_DIRECTORY ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
    COMMENT "Creating Java archive ${_JAVA_TARGET_OUTPUT_NAME}"
    VERBATIM
)

InsightSoftwareConsortium/ITK Wrapping/macro_files/itk_end_wrap_module.cmake :142

add_custom_command(
  OUTPUT ${igenerator_outputs}
  BYPRODUCTS ${igenerator_byproducts}
  COMMAND
    ${Python3_EXECUTABLE} ${IGENERATOR} ${mdx_opts} ${swig_libs} -w1 -w3 -w51 -w52 -w53 -w54 -A protected -A private
    -p ${PYGCCXML_DIR} -g ${CASTXML_EXECUTABLE} --snake-case-file "${snake_case_config_file}" --interface-output-dir
    "${WRAPPER_MASTER_INDEX_OUTPUT_DIR}" --library-output-dir "${WRAPPER_LIBRARY_OUTPUT_DIR}" --submodule-order
    "${THIS_MODULE_SUBMODULE_ORDER}" --pyi_index_list "${ITK_PYI_INDEX_FILES}" --pyi_dir "${ITK_STUB_DIR}" --pkl_dir
    "${ITK_PKL_DIR}"
  DEPENDS ${IGENERATOR}
          ${ITK_WRAP_DOC_DOCSTRING_FILES}
          ${CastXML_OUTPUT_FILES}
          ${typedef_in_files}
          ${mdx_files}
          ${WRAPPER_SWIG_LIBRARY_FILES}
  WORKING_DIRECTORY "${WRAPPING_CONFIG_WORKING_DIR}" # Arguments to WORKING_DIRECTORY may use generator expressions
  COMMENT "Run igenerator.py for ${WRAPPER_LIBRARY_NAME}"
  VERBATIM)

keepassxreboot/keepassxc docs/CMakeLists.txt :48

add_custom_command(OUTPUT keepassxc.1 keepassxc-cli.1
    COMMAND ${ASCIIDOCTOR_EXE} -D ${OUT_DIR} -b manpage ${REV} ./man/keepassxc.1.adoc
    COMMAND ${ASCIIDOCTOR_EXE} -D ${OUT_DIR} -b manpage ${REV} ./man/keepassxc-cli.1.adoc
    DEPENDS ${DOC_DIR}/man/keepassxc.1.adoc ${DOC_DIR}/man/keepassxc-cli.1.adoc
    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
    VERBATIM)

KhronosGroup/KTX cmake/mkvk.cmake :130

add_custom_command(
    OUTPUT ${makevk2dfd_output}
    COMMAND "${PERL_EXECUTABLE}" external/dfdutils/makevk2dfd.pl ${vulkan_header} external/dfdutils/vk2dfd.inl
    DEPENDS ${makevk2dfd_input}
    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
    COMMENT "Generating VkFormat/DFD switch body"
    VERBATIM
)

KhronosGroup/KTX cmake/mkvk.cmake :151

add_custom_command(
    OUTPUT ${makedfd2vk_output}
    COMMAND ${CMAKE_COMMAND} -E make_directory external/dfdutils
    COMMAND "${PERL_EXECUTABLE}" external/dfdutils/makedfd2vk.pl ${vulkan_header} external/dfdutils/dfd2vk.inl
    DEPENDS ${makedfd2vk_input}
    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
    COMMENT "Generating DFD/VkFormat switch body"
    VERBATIM
)

KhronosGroup/KTX cmake/version.cmake :177

add_custom_command(
    OUTPUT ${version_h_output}
    # On Windows this command has to be invoked by a shell in order to work
    COMMAND ${BASH_EXECUTABLE} -c "\"scripts/mkversion\" \"-v\" \"${KTX_GIT_VERSION_FULL}\" \"-o\" \"version.h\" \"${dest_path}\""
    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
    COMMENT "Generate ${version_h_output}"
    VERBATIM
)

KhronosGroup/KTX cmake/version.cmake :186

add_custom_command(
    OUTPUT ${version_h_output}
    COMMAND scripts/mkversion -v ${KTX_GIT_VERSION_FULL} -o version.h ${dest_path}
    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
    COMMENT "Generate ${version_h_output}"
    VERBATIM
)

KhronosGroup/KTX tests/loadtests/compile_shader.cmake :24

add_custom_command(OUTPUT
${frag2spirv_out}
COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/${shader_path}
COMMAND glslc "-fshader-stage=fragment" -o "${frag2spirv_out}" "${frag2spirv_in}"
DEPENDS ${frag2spirv_in}
WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
COMMENT "Compiling ${frag_name}."
VERBATIM
)

lammps/lammps cmake/Modules/Packages/GPU.cmake :366

add_custom_command(OUTPUT ${CUBIN_FILE}
  VERBATIM COMMAND ${HIP_HIPCC_EXECUTABLE} --genco -t="${HIP_ARCH}" -f=\"-O3 -DUSE_HIP -D_${GPU_PREC_SETTING} -DLAMMPS_${LAMMPS_SIZES} -I${LAMMPS_LIB_SOURCE_DIR}/gpu\" -o ${CUBIN_FILE} ${CU_CPP_FILE}
  DEPENDS ${CU_CPP_FILE}
  COMMENT "Generating ${CU_NAME}.cubin")

ledger/ledger doc/CMakeLists.txt :112

add_custom_command(OUTPUT ${file_base}.info
  COMMAND ${MAKEINFO} --force --no-split -o ${file_base}.info ${CMAKE_CURRENT_SOURCE_DIR}/${file}
  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${file}
  VERBATIM)

ledger/ledger doc/CMakeLists.txt :151

add_custom_command(OUTPUT ledger.1.html
  COMMAND ${BASH} -c "${MAN2HTML} ${CMAKE_CURRENT_SOURCE_DIR}/ledger.1 | tail -n+3 > ledger.1.html"
  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/ledger.1
  VERBATIM)

ledger/ledger doc/CMakeLists.txt :178

add_custom_command(OUTPUT ledger.html
  COMMAND ${CMAKE_COMMAND} -E env
    PYTHONPATH=${CMAKE_BINARY_DIR}
    ${Python_EXECUTABLE} -m pydoc -w ledger
  DEPENDS ${CMAKE_BINARY_DIR}/${_ledger_python_module_name}
  VERBATIM)

lexbor/lexbor config.cmake :365

add_custom_command(TARGET "${exe_name}"
    POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${LEXBOR_LIB_NAME}> $<TARGET_FILE_DIR:${exe_name}>
    COMMENT "Copy dll file to ${CMAKE_CURRENT_BINARY_DIR} directory" VERBATIM
)

analogdevicesinc/libad9361 CMakeLists.txt :140

add_custom_command(TARGET ad9361 POST_BUILD
	COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
	WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
	COMMENT "Generating API documentation with Doxygen" VERBATIM
	)

analogdevicesinc/libad9361 bindings/python/CMakeLists.txt :48

add_custom_command(TARGET libad9361-py-py POST_BUILD
	COMMAND ${CMAKE_COMMAND} -E env "LD_LIBRARY_PATH=$ENV{LD_LIBRARY_PATH}:${CMAKE_BINARY_DIR}"
	${SPHINX_EXECUTABLE}
		-b html
		-n
		-c ${CMAKE_CURRENT_SOURCE_DIR}/doc
		-d ${CMAKE_CURRENT_BINARY_DIR}/doctrees
		-w ${CMAKE_BINARY_DIR}/Spx_output_python
		${CMAKE_CURRENT_SOURCE_DIR}/doc
		${CMAKE_HTML_DEST_DIR}/python
	COMMENT "Generating Python binding documentation with Sphinx" VERBATIM
)

AOMediaCodec/libavif CMakeLists.txt :789

add_custom_command(
    OUTPUT ${MAN_PAGE}
    COMMAND ${PANDOC_EXE} -s -V "footer=libavif ${PROJECT_VERSION}" -f markdown -t man -o
            "${CMAKE_CURRENT_BINARY_DIR}/${MAN_PAGE}" "${CMAKE_CURRENT_SOURCE_DIR}/doc/${MAN_PAGE}.md"
    DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/doc/${MAN_PAGE}.md"
    VERBATIM
)

AOMediaCodec/libavif cmake/Modules/LocalSvt.cmake :81

add_custom_command(
    OUTPUT ${_svt_header_output}
    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${_svt_header_file} ${_svt_header_output}
    DEPENDS ${_svt_header_file}
    VERBATIM
)

analogdevicesinc/libiio cmake/Install.cmake :26

add_custom_command(TARGET iio-compat POST_BUILD
	COMMAND ${CMAKE_COMMAND} -E remove Current
	COMMAND ${CMAKE_COMMAND} -E create_symlink ${PROJECT_VERSION} Current
	WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/iio.framework/Versions
	COMMENT "Fixup Current symbolic link" VERBATIM)

analogdevicesinc/libiio cmake/Install.cmake :102

add_custom_command(TARGET iio POST_BUILD
	COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
	WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
	COMMENT "Generating API documentation with Doxygen" VERBATIM)

analogdevicesinc/libiio cmake/Install.cmake :106

add_custom_command(TARGET iio POST_BUILD
	COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_csharp
	WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
	COMMENT "Generating C# documentation with Doxygen" VERBATIM)

libnegf/libnegf src/CMakeLists.txt :77

add_custom_command(
  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${f90src}
  COMMAND ${FYPP}
    -I${PROJECT_SOURCE_DIR}/include
    ${fyppdefs} ${CMAKE_CURRENT_SOURCE_DIR}/${fppsrc}
    ${CMAKE_CURRENT_BINARY_DIR}/${f90src}
  MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${fppsrc}
  DEPENDS ${PROJECT_SOURCE_DIR}/include/assert.fypp
  VERBATIM)

jtv/libpqxx src/CMakeLists.txt :56

add_custom_command(TARGET ${tgt} POST_BUILD
    COMMAND "$<IF:$<STREQUAL:${name},${output_name}>,${noop_command},${create_symlink_command}>"
    VERBATIM
    COMMAND_EXPAND_LISTS
)

sbmlteam/libsbml docs/CMakeLists.txt :302

	ADD_CUSTOM_COMMAND(
		OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/formatted/java-api/index.html
		COMMAND ${Java_JAVAC_EXECUTABLE}
		ARGS -nowarn
			 -cp "${Java_JAVADOC_JAR}"
			 ${CMAKE_CURRENT_SOURCE_DIR}/src/SBMLDoclet.java
			  -d "${current_dir}"
		COMMAND ${Java_JAVA_EXECUTABLE}
		ARGS  -cp "${Java_JAVADOC_JAR}${FILE_SEP}${current_dir}"
		      SBMLDoclet
			  -use -public -version -author -sourcetab 4 -keywords -nohelp
			  -link http://docs.oracle.com/javase/1.6.0/docs/api
			  -tag note:a:"Note:"
			  -tag warning:a:"Warning:"
			  -excludefile java-skip.txt
			  -header "${LIBSBML_JAVADOC_HEADER}"
			  -bottom "${LIBSBML_JAVADOC_FOOTER}"
			  -windowtitle ${LIBSBML_JAVADOC_WINDOWTITLE}
			  -doctitle ${LIBSBML_JAVADOC_DOCTITLE}
			  -overview libsbml-java-fake-overview.html
			  -stylesheetfile css/libsbml-javadoc-stylesheet.css
			  -d ${output_dir}
	          -sourcepath ${java_dir} org.sbml.libsbml
		COMMENT "Generate Java-API Documentation"
		VERBATIM
		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/src

		COMMAND "${CMAKE_COMMAND}"
		ARGS -E copy
			"${logo_file}"
			"${output_dir}"

		COMMAND "${CMAKE_COMMAND}"
		ARGS -E copy
			"${sbml_js}"
			"${output_dir}"

#		COMMAND "${CMAKE_COMMAND}"
#		ARGS -E copy
#			"${tabs_css}"
#			"${output_dir}"

#		COMMAND "${CMAKE_COMMAND}"
#		ARGS -E copy
#			${logo_file}
#			${java_output_dir}
#
		COMMAND "${CMAKE_COMMAND}"
		ARGS -DPACKAGE_VERSION=\"${PACKAGE_VERSION}\"
			-Djava_manual=${CMAKE_CURRENT_SOURCE_DIR}/formatted/java-api
			-P ${CMAKE_CURRENT_SOURCE_DIR}/process-java-doc.cmake

		DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
				${CMAKE_CURRENT_SOURCE_DIR}/process-java-doc.cmake

		)

MapServer/MapServer cmake/FindProtobufC.cmake :72

add_custom_command(
  OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.${PROTBUFC_SOURCE_EXTENSION}"
         "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.${PROTBUFC_HEADER_EXTENSION}"
  COMMAND  ${PROTOBUFC_COMPILER}
  ARGS --c_out ${CMAKE_CURRENT_BINARY_DIR} -I ${CMAKE_CURRENT_SOURCE_DIR} -I ${FIL_PATH} ${ABS_FIL}
  DEPENDS ${ABS_FIL}
  COMMENT "Running protobuf-c compiler on ${FIL}"
  VERBATIM )

rui314/mold CMakeLists.txt :426

add_custom_command(
  TARGET mold POST_BUILD
  COMMAND ${CMAKE_COMMAND} -E create_symlink mold ld
  BYPRODUCTS ld
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  VERBATIM)

cmake add_custom_command(VERBATIM) examples