cmake examples

antlr/antlr4 runtime/Cpp/cmake/FindANTLR.cmake :104

add_custom_command(
    OUTPUT ${ANTLR_${Name}_OUTPUTS}
    COMMAND ${Java_JAVA_EXECUTABLE} -jar ${ANTLR_EXECUTABLE}
            ${InputFile}
            -o ${ANTLR_${Name}_OUTPUT_DIR}
            -no-listener
            -Dlanguage=Cpp
            ${ANTLR_TARGET_COMPILE_FLAGS}
    DEPENDS ${InputFile}
            ${ANTLR_TARGET_DEPENDS}
    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
    COMMENT "Building ${Name} with ANTLR ${ANTLR_VERSION}")

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)

google/benchmark test/CMakeLists.txt :287

add_custom_command(
  OUTPUT ${CMAKE_BINARY_DIR}/lcov/index.html
  COMMAND ${LCOV} -q -z -d .
  COMMAND ${LCOV} -q --no-external -c -b "${CMAKE_SOURCE_DIR}" -d . -o before.lcov -i
  COMMAND ${CTEST} --force-new-ctest-process
  COMMAND ${LCOV} -q --no-external -c -b "${CMAKE_SOURCE_DIR}" -d . -o after.lcov
  COMMAND ${LCOV} -q -a before.lcov -a after.lcov --output-file final.lcov
  COMMAND ${LCOV} -q -r final.lcov "'${CMAKE_SOURCE_DIR}/test/*'" -o final.lcov
  COMMAND ${GENHTML} final.lcov -o lcov --demangle-cpp --sort -p "${CMAKE_BINARY_DIR}" -t benchmark
  DEPENDS filter_test benchmark_test options_test basic_test fixture_test complexity_test
  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
  COMMENT "Running LCOV"
)

mono/boringssl crypto/CMakeLists.txt :43

add_custom_command(
  OUTPUT ${dest}
  COMMAND ${PERL_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${src} ${PERLASM_STYLE} ${PERLASM_FLAGS} ${ARGN} > ${dest}
  DEPENDS
  ${src}
  ${PROJECT_SOURCE_DIR}/crypto/perlasm/arm-xlate.pl
  ${PROJECT_SOURCE_DIR}/crypto/perlasm/x86_64-xlate.pl
  ${PROJECT_SOURCE_DIR}/crypto/perlasm/x86asm.pl
  ${PROJECT_SOURCE_DIR}/crypto/perlasm/x86gas.pl
  ${PROJECT_SOURCE_DIR}/crypto/perlasm/x86masm.pl
  ${PROJECT_SOURCE_DIR}/crypto/perlasm/x86nasm.pl
  WORKING_DIRECTORY .
)

mono/boringssl crypto/err/CMakeLists.txt :3

#add_custom_command(
#  OUTPUT err_data.c
#  COMMAND ${GO_EXECUTABLE} run err_data_generate.go > ${CMAKE_CURRENT_BINARY_DIR}/err_data.c
#  DEPENDS
#  err_data_generate.go
#  asn1.errordata
#  bio.errordata
#  bn.errordata
#  cipher.errordata
#  conf.errordata
#  dh.errordata
#  digest.errordata
#  dsa.errordata
#  ecdh.errordata
#  ecdsa.errordata
#  ec.errordata
#  engine.errordata
#  evp.errordata
#  hkdf.errordata
#  obj.errordata
#  pem.errordata
#  pkcs8.errordata
#  rsa.errordata
#  ssl.errordata
#  x509.errordata
#  x509v3.errordata
#  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
#)

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

mozilla/cbindgen tests/depfile/cbindgen_test.cmake :13

add_custom_command(
    OUTPUT
    "${header_destination}" "${depfile_destination}"
    COMMAND
    "${CBINDGEN_PATH}"
    --output "${header_destination}"
    --depfile "${depfile_destination}"
    ${ARGN}
    DEPFILE "${depfile_destination}"
    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
    COMMENT "Running cbindgen"
    COMMAND_EXPAND_LISTS
)

CGAL/cgal Periodic_3_triangulation_3/demo/Periodic_Lloyd_3/CMakeLists.txt :34

add_custom_command(
  OUTPUT Periodic_Lloyd_3.qhc
  DEPENDS Periodic_Lloyd_3.qhp Periodic_Lloyd_3.qhcp
  COMMAND
    ${CGAL_QCOLLECTIONGENERATOR_TARGET}
    ${CMAKE_CURRENT_SOURCE_DIR}/Periodic_Lloyd_3.qhcp -o
    ${CMAKE_CURRENT_BINARY_DIR}/Periodic_Lloyd_3.qhc
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})

mosra/corrade modules/UseCorrade.cmake :769

add_custom_command(TARGET ${plugin_name} POST_BUILD
    # This would be nice to Ninja, but BYPRODUCTS don't support generator
    # expressions right now (last checked: CMake 3.16)
    #BYPRODUCTS $<TARGET_FILE_DIR:${plugin_name}>/${plugin_name}${metadata_file_suffix}
    COMMAND ${CMAKE_COMMAND} -E copy ${metadata_file} $<TARGET_FILE_DIR:${plugin_name}>/${plugin_name}${metadata_file_suffix}
    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})

mosra/corrade modules/UseCorrade.cmake :830

add_custom_command(
    OUTPUT ${resource_out}
    COMMAND ${command} ${plugin_name} --single ${metadata_file} ${resource_out}
    DEPENDS Corrade::rc ${metadata_file}
    COMMENT "Compiling static plugin metadata file ${resource_out}"
    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})

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
)

microsoft/DirectXTex CMakeLists.txt :218

add_custom_command(
    OUTPUT "${COMPILED_SHADERS}/BC6HEncode_EncodeBlockCS.inc"
    MAIN_DEPENDENCY "${PROJECT_SOURCE_DIR}/DirectXTex/Shaders/CompileShaders.cmd"
    DEPENDS ${SHADER_SOURCES}
    COMMENT "Generating HLSL shaders..."
    COMMAND ${CMAKE_COMMAND} -E env CompileShadersOutput="${COMPILED_SHADERS}" $<$<BOOL:${DIRECTX_FXC_TOOL}>:LegacyShaderCompiler=${DIRECTX_FXC_TOOL}> CompileShaders.cmd > "${COMPILED_SHADERS}/compileshaders.log"
    WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/DirectXTex/Shaders"
    USES_TERMINAL)

microsoft/DirectXTex CMakeLists.txt :534

add_custom_command(
      OUTPUT "${COMPILED_SHADERS}/ddsview_ps1D.inc"
      MAIN_DEPENDENCY "${PROJECT_SOURCE_DIR}/DDSView/hlsl.cmd"
      DEPENDS "DDSView/ddsview.hlsl"
      COMMENT "Generating HLSL shaders for DDSView..."
      COMMAND ${CMAKE_COMMAND} -E env CompileShadersOutput="${COMPILED_SHADERS}" $<$<BOOL:${DIRECTX_FXC_TOOL}>:LegacyShaderCompiler=${DIRECTX_FXC_TOOL}> hlsl.cmd > "${COMPILED_SHADERS}/hlsl_ddsview.log"
      WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/DDSView"
      USES_TERMINAL)

microsoft/DirectXTK CMakeLists.txt :249

add_custom_command(
    OUTPUT "${COMPILED_SHADERS}/SpriteEffect_SpriteVertexShader.inc"
    MAIN_DEPENDENCY "${PROJECT_SOURCE_DIR}/Src/Shaders/CompileShaders.cmd"
    DEPENDS ${SHADER_SOURCES}
    COMMENT "Generating HLSL shaders..."
    COMMAND ${CMAKE_COMMAND} -E env CompileShadersOutput="${COMPILED_SHADERS}" $<$<BOOL:${DIRECTX_FXC_TOOL}>:LegacyShaderCompiler=${DIRECTX_FXC_TOOL}> CompileShaders.cmd ARGS ${ShaderOpts} > "${COMPILED_SHADERS}/compileshaders.log"
    WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/Src/Shaders"
    USES_TERMINAL)

doxygen/doxygen examples/CMakeLists.txt :94

add_custom_command(
  COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/chm/html/examples/${f}
  COMMAND ${CMAKE_COMMAND} -E env PROJECT_BINARY_DIR=${PROJECT_BINARY_DIR} EXTRA_SETTINGS=chmexample.cfg ${EXECUTABLE_OUTPUT_PATH}/doxygen ${f}.cfg
  DEPENDS doxygen ${f}.${f_ext} ${f}.cfg ${f_dep_chm} baseexample.cfg chmexample.cfg
  OUTPUT ${PROJECT_BINARY_DIR}/chm/html/examples/${f}/html/index.html
  WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/examples
)

doxygen/doxygen examples/CMakeLists.txt :122

add_custom_command(
      COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/html/examples/diagrams
      COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/latex/examples/diagrams
      COMMAND ${CMAKE_COMMAND} -E env PROJECT_BINARY_DIR=${PROJECT_BINARY_DIR} EXTRA_SETTINGS=docuexample.cfg ${EXECUTABLE_OUTPUT_PATH}/doxygen diagrams.cfg
      COMMAND ${Python_EXECUTABLE}  ${TOP}/examples/strip_example.py  < ${PROJECT_BINARY_DIR}/latex/examples/diagrams/latex/refman.tex > ${PROJECT_BINARY_DIR}/latex/examples/diagrams/latex/refman_doc.tex
      DEPENDS doxygen diagrams_a.h diagrams_b.h diagrams_c.h diagrams_d.h diagrams_e.h diagrams.cfg ${TOP}/examples/strip_example.py baseexample.cfg docuexample.cfg
      OUTPUT ${PROJECT_BINARY_DIR}/html/examples/diagrams/html/index.html ${PROJECT_BINARY_DIR}/latex/examples/diagrams/latex/refman_doc.tex
      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/examples
)

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

duckdb/duckdb CMakeLists.txt :1514

add_custom_command(
        OUTPUT ${PROJECT_BINARY_DIR}/duckdb_platform_out
        DEPENDS duckdb_platform_binary
        COMMAND duckdb_platform_binary > ${PROJECT_BINARY_DIR}/duckdb_platform_out || ( echo "Provide explicit DUCKDB_PLATFORM=your_target_arch to avoid build-type detection of the platform" && exit 1 )
        WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
        )

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

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

add_custom_command(OUTPUT "${PVS_STUDIO_CONFIG}"
                   COMMAND ${PVS_STUDIO_CONFIG_COMMAND}
                   WORKING_DIRECTORY "${BINARY_DIR}"
                   COMMENT "Generating PVS-Studio.cfg")

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

add_custom_command(
    OUTPUT "${COMPILE_COMMANDS_LOG}"
    COMMAND "${PVS_STUDIO_BIN}" analyze -i
            --output-file "${COMPILE_COMMANDS_LOG}.always"
            ${PVS_STUDIO_ARGS}
    COMMENT "Analyzing with PVS-Studio"
    WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
    DEPENDS "${PVS_STUDIO_SUPPRESS_BASE}" "${PVS_STUDIO_DEPENDS}"
)

google/flatbuffers CMake/BuildFlatBuffers.cmake :112

add_custom_command(
  OUTPUT ${binary_schema}
  COMMAND ${FLATC} -b --schema
  -o ${binary_schemas_dir}
  ${include_params}
  ${schema}
  DEPENDS ${FLATC_TARGET} ${schema} ${additional_dependencies}
  WORKING_DIRECTORY "${working_dir}")

google/flatbuffers CMake/BuildFlatBuffers.cmake :278

add_custom_command(
  OUTPUT ${binary_schema}
  COMMAND ${FLATC} -b --schema
  -o ${FLATBUFFERS_GENERATE_HEADERS_BINARY_SCHEMAS_DIR}
  ${include_params}
  ${schema}
  DEPENDS ${FLATC_TARGET} ${schema}
  WORKING_DIRECTORY "${working_dir}")

google/flatbuffers CMake/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})

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

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

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

facebook/folly build/fbcode_builder/CMake/FBThriftPyLibrary.cmake :79

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

facebook/folly folly/CMakeLists.txt :80

add_custom_command(TARGET folly_python_bindings POST_BUILD
  COMMAND ${CMAKE_COMMAND} -E env
    "CFLAGS=${CMAKE_C_FLAGS}"
    "CXXFLAGS=${CMAKE_CXX_FLAGS}"
    "CC=${CMAKE_C_COMPILER}"
    "CXX=${CMAKE_CXX_COMPILER}"
    python3 ${CMAKE_CURRENT_SOURCE_DIR}/python/setup.py
    build_ext -f ${incs} ${libs}
  BYPRODUCTS
    ${_cybld}/folly/executor_api.h
    ${_cybld}/folly/iobuf_api.h
  WORKING_DIRECTORY ${_cybld}
)

facebook/folly folly/CMakeLists.txt :133

add_custom_command(TARGET folly_python_bindings
  COMMAND ${CMAKE_COMMAND} -E env
    "CFLAGS=${CMAKE_C_FLAGS}"
    "CXXFLAGS=${CMAKE_CXX_FLAGS}"
    "CC=${CMAKE_C_COMPILER}"
    "CXX=${CMAKE_CXX_COMPILER}"
    python3 ${CMAKE_CURRENT_SOURCE_DIR}/python/setup.py
    bdist_wheel
  WORKING_DIRECTORY ${_cybld}
)

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 wcml/CMakeLists.txt :13

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

pietrodelugas/fox wcml/CMakeLists.txt :31

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

pietrodelugas/fox wcml/CMakeLists.txt :49

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

pietrodelugas/fox wcml/CMakeLists.txt :58

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

pietrodelugas/fox wkml/CMakeLists.txt :4

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

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
)

FreeCAD/FreeCAD cMake/FreeCadMacros.cmake :167

add_custom_command(
    OUTPUT "${SOURCE_H_PATH}" "${SOURCE_CPP_PATH}"
    COMMAND ${Python3_EXECUTABLE} "${TOOL_NATIVE_PATH}" --outputPath "${OUTPUT_NATIVE_PATH}" ${BASE_NAME}.pyi
    MAIN_DEPENDENCY "${CMAKE_CURRENT_SOURCE_DIR}/${BASE_NAME}.pyi"
    DEPENDS
        "${CMAKE_SOURCE_DIR}/src/Tools/bindings/templates/templateClassPyExport.py"
        "${TOOL_PATH}"
    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
    COMMENT "Building ${BASE_NAME}Py${SUFFIX}.h/.cpp out of ${BASE_NAME}.pyi"
)

FreeCAD/FreeCAD cMake/FreeCadMacros.cmake :191

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

FreeCAD/FreeCAD src/Build/CMakeLists.txt :12

add_custom_command(
    OUTPUT version_file
    BYPRODUCTS ${CMAKE_CURRENT_BINARY_DIR}/Version.h
    COMMAND ${Python3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/src/Tools/SubWCRev.py
        --srcdir=${CMAKE_SOURCE_DIR} --bindir=${CMAKE_BINARY_DIR}
    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_BINARY_DIR}/Version.h.out
        ${CMAKE_CURRENT_BINARY_DIR}/Version.h
    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
    DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/Version.h.in)

FreeRDP/FreeRDP client/common/man/CMakeLists.txt :23

add_custom_command(
  OUTPUT ${MAN_OPTIONS_FILE} COMMAND $<TARGET_FILE:generate_argument_manpage> "${MAN_OPTIONS_FILE}"
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} DEPENDS generate_argument_manpage
)

KDAB/GammaRay cmake/FindQmlLint.cmake :57

add_custom_command(
    OUTPUT ${_file}.lint
    COMMAND ${QmlLint_EXECUTABLE} ${_file_abs}
    COMMAND ${CMAKE_COMMAND} -E touch ${_file}.lint
    MAIN_DEPENDENCY ${_file_abs}
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    COMMENT "Run qmllint on ${_file}"
)

KDAB/GammaRay docs/api/CMakeLists.txt :25

add_custom_command(
    OUTPUT ${DOXYGEN_OUTPUT_DIR}/qch/gammaray-api.qch
    COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
    #copy some files by-hand that are referred to by the markdown README
    COMMAND ${CMAKE_COMMAND} -E make_directory ${DOXYGEN_OUTPUT_DIR}/html/LICENSES
    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_SOURCE_DIR}/LICENSES/GPL-2.0-or-later.txt
            ${DOXYGEN_OUTPUT_DIR}/html/LICENSES
    COMMAND ${CMAKE_COMMAND} -E make_directory ${DOXYGEN_OUTPUT_DIR}/html/docs
    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_SOURCE_DIR}/docs/GammaRay-CopyrightAssignmentForm.pdf
            ${DOXYGEN_OUTPUT_DIR}/html/docs
    DEPENDS ${_all_hdrs} ${_dox_deps} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
    COMMENT "Generate the .qch file"
)

OSGeo/gdal cmake/modules/thirdparty/FindDotnet.cmake :405

ADD_CUSTOM_COMMAND(
    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${DOTNET_PROJNAME}.runtimestamp ${DOTNET_RUN_OUTPUT}
    DEPENDS ${DOTNET_deps}
    COMMAND ${DOTNET_EXE} restore ${DOTNET_PROJPATH} ${DOTNET_IMPORT_PROPERTIES}
    COMMAND ${DOTNET_EXE} clean ${DOTNET_PROJPATH} ${DOTNET_BUILD_PROPERTIES}
    COMMAND ${DOTNET_EXE} build --no-restore ${DOTNET_PROJPATH} -c ${DOTNET_CONFIG} ${DOTNET_BUILD_PROPERTIES} ${DOTNET_BUILD_OPTIONS}
    # XXX tfm
    COMMAND ${DOTNET_EXE} ${DOTNET_OUTPUT_PATH}/netcoreapp3.1/${DOTNET_PROJNAME}.dll ${DOTNET_ARGUMENTS}
    COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/${DOTNET_PROJNAME}.runtimestamp
    WORKING_DIRECTORY ${DOTNET_OUTPUT_PATH})

OSGeo/gdal doc/CMakeLists.txt :107

add_custom_command(
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/doxygen_html.stamp
        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
        DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_html ${DOXYGEN_SOURCE_FILES}
        COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_html
        COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/doxygen_html.stamp
)

OSGeo/gdal fuzzers/CMakeLists.txt :154

add_custom_command(
  OUTPUT ${FUZZ_CORPUS}
  COMMAND env OUT=${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/build_seed_corpus.sh
  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
  USES_TERMINAL)

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

add_custom_command(
  # create the sub folder
  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_CSHARP_WRAPPER}.cpp
  COMMAND ${CMAKE_COMMAND} -E make_directory ${_CSHARP_WORKING_DIRECTORY}
  # SWIG command
  COMMAND
    ${SWIG_EXECUTABLE} -namespace ${_CSHARP_NAMESPACE} -outdir ${_CSHARP_WORKING_DIRECTORY} -DSWIG2_CSHARP -dllimport
    ${_CSHARP_WRAPPER} -Wall -I${PROJECT_SOURCE_DIR}/swig/include -I${PROJECT_SOURCE_DIR}/swig/include/csharp
    -I${PROJECT_SOURCE_DIR}/gdal -c++ -csharp -o ${_CSHARP_WRAPPER}.cpp ${_CSHARP_SWIG_INTERFACE}
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  DEPENDS ${GDAL_SWIG_COMMON_INTERFACE_FILES} ${PROJECT_SOURCE_DIR}/swig/include/csharp/typemaps_csharp.i
          ${_CSHARP_SWIG_INTERFACE})

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/python/CMakeLists.txt :287

add_custom_command(
  OUTPUT ${PY_SO_LIST}
  COMMAND ${CMAKE_COMMAND} -E env "\"PATH=${PROJECT_BINARY_DIR}/apps${PATH_SEP}$ENV{PATH}\"" ${CMAKE_COMMAND} ${WERROR_DEV_FLAG} -P "${BUILD_EXT_FILENAME}"
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  DEPENDS ${GDAL_LIB_DEP_FOR_PY_SO} ${GDAL_PYTHON_PYSOURCES} ${GDAL_PYTHON_CSOURCES} "${BUILD_EXT_FILENAME}"
          ${PROJECT_SOURCE_DIR}/gcore/gdal_priv.h)

malaterre/GDCM CMake/FindMd5sum.cmake :46

add_custom_command(
  OUTPUT    ${OUTPUT_FILE}
  COMMAND   cmake
  ARGS      -P ${CMAKE_BINARY_DIR}/md5sum.cmake
  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
  DEPENDS   ${DIRECTORY} ${CMAKE_BINARY_DIR}/md5sum.cmake
  COMMENT   "Generating md5sums"
  )

malaterre/GDCM CMake/UseCSharp.cmake :130

add_custom_command(
  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${name}.dll
  COMMAND ${CMAKE_CSHARP_COMPILER}
  ARGS "/t:library" "/out:${name}.dll" ${csharp_cs_sources}
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  DEPENDS "${csharp_cs_sources_dep}"
  COMMENT "Creating Csharp library ${name}.cs"
)

malaterre/GDCM CMake/UseCSharp.cmake :188

add_custom_command(
  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${name}.exe
  COMMAND ${CMAKE_CSHARP_COMPILER}
  #ARGS "/r:gdcm_csharp.dll" "/out:${name}.exe" ${csharp_cs_sources}
  ARGS ${CSHARP_EXECUTABLE_${name}_ARGS}
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  #DEPENDS ${csharp_cs_sources}
  COMMENT "Create ${name}.exe"
)

malaterre/GDCM Examples/Java/CMakeLists.txt :22

add_custom_command(
  OUTPUT ${GDCM_EXECUTABLE_DIR}/${example}.class
  COMMAND ${Java_JAVAC_EXECUTABLE} ARGS -source ${GDCM_JAVA_SOURCE_VERSION} -target ${GDCM_JAVA_TARGET_VERSION} ${CMAKE_CURRENT_SOURCE_DIR}/${example}.java -d ${GDCM_EXECUTABLE_DIR} -classpath ${GDCM_LIBRARY_DIR}/gdcm.jar
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${example}.java
  COMMENT "javac ${example}.java"
  )

malaterre/GDCM Testing/Source/DataStructureAndEncodingDefinition/Java/CMakeLists.txt :19

add_custom_command(
  OUTPUT ${GDCM_EXECUTABLE_DIR}/${example}.class
  COMMAND ${Java_JAVAC_EXECUTABLE} ARGS ${CMAKE_CURRENT_SOURCE_DIR}/${example}.java -encoding utf-8 -d ${GDCM_EXECUTABLE_DIR} -source ${GDCM_JAVA_SOURCE_VERSION} -target ${GDCM_JAVA_TARGET_VERSION} -classpath ${GDCM_LIBRARY_DIR}/gdcm.jar
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${example}.java
  COMMENT "javac ${example}.java"
  )

malaterre/GDCM Testing/Source/MediaStorageAndFileFormat/Java/CMakeLists.txt :16

add_custom_command(
  OUTPUT ${GDCM_EXECUTABLE_DIR}/${example}.class
  COMMAND ${Java_JAVAC_EXECUTABLE} ARGS ${CMAKE_CURRENT_SOURCE_DIR}/${example}.java -d ${GDCM_EXECUTABLE_DIR} -source ${GDCM_JAVA_SOURCE_VERSION} -target ${GDCM_JAVA_TARGET_VERSION} -classpath ${GDCM_LIBRARY_DIR}/gdcm.jar
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${example}.java
  COMMENT "javac ${example}.java"
  )

malaterre/GDCM Utilities/doxygen/CMakeLists.txt :79

add_custom_command(
  OUTPUT   ${CMAKE_CURRENT_BINARY_DIR}/html/index.html
           ${CMAKE_CURRENT_BINARY_DIR}/latex/Makefile
  # let's create the tarball within the same custom command to avoid complex dep. rules.
           ${GDCM_DOC_TARBALL}
           ${CMAKE_CURRENT_BINARY_DIR}/latex/refman.tex # output #1 (fake)
  # 1. first thing first let's run doxygen
  COMMAND  ${DOXYGEN}
  ARGS     ${GDCM_BINARY_DIR}/Utilities/doxygen/Doxyfile
  # 2. tarball gen.
  COMMAND  ${CMAKE_COMMAND}
  ARGS     -E tar cfz ${GDCM_DOC_TARBALL} html
  DEPENDS  ${GDCM_BINARY_DIR}/Utilities/doxygen/Doxyfile
           ${GDCM_BINARY_DIR}/Utilities/doxygen/README.txt
           ${GDCM_BINARY_DIR}/Utilities/doxygen/TestsList.txt
           ${headerfiles}
  COMMENT  "GDCM: Creating doxygen doc + tarball"
  #WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  )

malaterre/GDCM Utilities/doxygen/CMakeLists.txt :135

add_custom_command(
  OUTPUT   ${CMAKE_CURRENT_BINARY_DIR}/latex/gdcm-${GDCM_VERSION}.pdf
  COMMAND  ${PDFOPT_EXECUTABLE}
  ARGS     ${CMAKE_CURRENT_BINARY_DIR}/latex/refman.pdf
           ${CMAKE_CURRENT_BINARY_DIR}/latex/gdcm-${GDCM_VERSION}.pdf
  DEPENDS  ${CMAKE_CURRENT_BINARY_DIR}/latex/refman.pdf
  COMMENT  "GDCM: Creating optimized pdf version of documentation"
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/latex
  )

malaterre/GDCM Utilities/doxygen/CMakeLists.txt :145

add_custom_command(
  OUTPUT   ${CMAKE_CURRENT_BINARY_DIR}/latex/gdcm-${GDCM_VERSION}.pdf
  COMMAND  ${CMAKE_COMMAND} -E copy
  ARGS     ${CMAKE_CURRENT_BINARY_DIR}/latex/refman.pdf
           ${CMAKE_CURRENT_BINARY_DIR}/latex/gdcm-${GDCM_VERSION}.pdf
  DEPENDS  ${CMAKE_CURRENT_BINARY_DIR}/latex/refman.pdf
  COMMENT  "GDCM: Creating unoptimized pdf version of documentation"
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/latex
  )

malaterre/GDCM Utilities/VTK/CMakeLists.txt :611

#    add_custom_command(
#      OUTPUT ${GDCM_LIBRARY_DIR}/vtkgdcm-sharp.dll
#      COMMAND ${CMAKE_CSHARP_COMPILER} ARGS "/r:${ACTIVIZ_KITWARE_VTK_LIBRARY}" "/r:${ACTIVIZ_KITWARE_MUMMY_RUNTIME_LIBRARY}" "/t:library" "/out:${GDCM_LIBRARY_DIR}/vtkgdcm-sharp.dll" "*.cs"
#      #COMMAND ${CMAKE_CSHARP_COMPILER} ARGS "/t:library" "/out:${GDCM_LIBRARY_DIR}/vtkgdcm-sharp.dll" "*.cs"
#      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
#      DEPENDS "${swig_generated_file_fullname}"
#      ${CMAKE_CURRENT_BINARY_DIR}/AssemblyInfo.cs
#      COMMENT "csc *.cs"
#      )

malaterre/GDCM Utilities/VTK/CMakeLists.txt :638

add_custom_command(
  OUTPUT ${GDCM_LIBRARY_DIR}/vtkgdcm-sharp.dll
  COMMAND ${CMAKE_CSHARP_COMPILER} ARGS "/t:library" "/out:${GDCM_LIBRARY_DIR}/vtkgdcm-sharp.dll" "*.cs"
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  DEPENDS ${SWIG_MODULE_vtkgdcmsharpglue_REAL_NAME} 
  ${CMAKE_CURRENT_BINARY_DIR}/AssemblyInfo.cs
  COMMENT "csc *.cs"
  )

malaterre/GDCM Utilities/VTK/CMakeLists.txt :734

add_custom_command(
  OUTPUT ${LIBRARY_OUTPUT_PATH}/vtkgdcm.jar
  #COMMAND ${Java_JAVAC_EXECUTABLE} ARGS -cp ${GDCM_VTK_JAVA_JAR} "vtk/*.java"
  # No such thing as -cp for javac only java is listed:
  # http://java.sun.com/j2se/1.5.0/docs/tooldocs/windows/classpath.html
  COMMAND ${Java_JAVAC_EXECUTABLE} ARGS ${jflags} -source ${GDCM_JAVA_SOURCE_VERSION} -target ${GDCM_JAVA_TARGET_VERSION} -classpath ${GDCM_VTK_JAVA_JAR} -d . "vtk/*.java"
  COMMAND ${Java_JAR_EXECUTABLE} ARGS -cvfm ${LIBRARY_OUTPUT_PATH}/${PROJECT_NAME}.jar ${CMAKE_CURRENT_SOURCE_DIR}/manifest.txt vtk/*.class
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/java
  DEPENDS ${VTKGDCM_NAME}Java
  #${VTK_JAVA_DEPENDENCIES}
  #vtkgdcmJavaJavaClasses
  COMMENT   "javac *.java -> jar; jar cvf -> vtkgdcm.jar"
)

malaterre/GDCM Utilities/VTK/Examples/Java/CMakeLists.txt :23

add_custom_command(
  OUTPUT ${EXECUTABLE_OUTPUT_PATH}/${example}.class
  COMMAND ${Java_JAVAC_EXECUTABLE} ARGS -source ${GDCM_JAVA_SOURCE_VERSION} -target ${GDCM_JAVA_TARGET_VERSION} -classpath "${classpath}"
  ${CMAKE_CURRENT_SOURCE_DIR}/${example}.java -d ${EXECUTABLE_OUTPUT_PATH}
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${example}.java
  COMMENT "javac ${example}.java"
  )

malaterre/GDCM Wrapping/Csharp/CMakeLists.txt :81

add_custom_command(
  OUTPUT ${GDCM_LIBRARY_DIR}/gdcm-sharp.dll
  COMMAND ${CMAKE_CSHARP_COMPILER}
  ARGS "/t:library"
  $<$<CONFIG:Debug>:/debug>
  $<$<CONFIG:Debug>:/pdb:${GDCM_LIBRARY_DIR}/gdcm-sharp>
  "/doc:${GDCM_LIBRARY_DIR}/gdcm-sharp.dll.xml" "/out:${GDCM_LIBRARY_DIR}/gdcm-sharp.dll" "*.cs"
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  DEPENDS "${swig_generated_file_fullname}"
  ${CMAKE_CURRENT_BINARY_DIR}/AssemblyInfo.cs
  COMMENT "csc *.cs"
  )

cginternals/glbinding docs/api-docs/CMakeLists.txt :49

add_custom_command(
    OUTPUT              ${doxyfile_html}
    DEPENDS             ${doxyfile} ${META_PROJECT_NAME}::glbinding ${META_PROJECT_NAME}::glbinding-aux
    WORKING_DIRECTORY   ${path}
    COMMAND             ${CMAKE_COMMAND} -E copy_directory ${path} ${doxyfile_directory} # ToDO, configure doxygen to use source as is
    COMMAND             ${DOXYGEN} \"${doxyfile}\"
    COMMENT             "Creating doxygen documentation."
)

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)

cginternals/globjects docs/api-docs/CMakeLists.txt :49

add_custom_command(
    OUTPUT              ${doxyfile_html}
    DEPENDS             ${doxyfile} ${META_PROJECT_NAME}::globjects
    WORKING_DIRECTORY   ${path}
    COMMAND             ${CMAKE_COMMAND} -E copy_directory ${path} ${doxyfile_directory} # ToDO, configure doxygen to use source as is
    COMMAND             ${DOXYGEN} \"${doxyfile}\"
    COMMENT             "Creating doxygen documentation."
)

sciapp/gr CMakeLists.txt :1212

add_custom_command(
  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/GKSTerm-build/quartz/GKSTerm.xcodeproj
  COMMAND ${CMAKE_COMMAND} -E copy_directory lib/gks ${CMAKE_CURRENT_BINARY_DIR}/GKSTerm-build
  COMMAND sed -e s%../../../3rdparty/build/lib/libzmq.a%${ZeroMQ_LIBRARY}% -e s%../../../3rdparty/build/include/zmq.h%${ZeroMQ_INCLUDE_DIR}/zmq.h% ${CMAKE_SOURCE_DIR}/lib/gks/quartz/GKSTerm.xcodeproj/project.pbxproj >${CMAKE_CURRENT_BINARY_DIR}/GKSTerm-build/quartz/GKSTerm.xcodeproj/project.pbxproj
  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
  DEPENDS ${GKS_SOURCES} ${GKSTERM_SOURCES}
)

steveire/grantlee examples/contacts/cmake/modules/FindGettext.cmake :219

add_custom_command(OUTPUT ${_gmoFile}
      COMMAND ${GETTEXT_MSGFMT_EXECUTABLE} -o ${_gmoFile} ${_current_PO_FILE}
      WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
      DEPENDS ${_current_PO_FILE}
   )

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)

grpc/grpc examples/android/helloworld/app/CMakeLists.txt :38

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}.pb.cc"
         "${GRPC_PROTO_GENS_DIR}/${RELFIL_WE}.pb.h"
  COMMAND ${helloworld_PROTOBUF_PROTOC_EXECUTABLE}
  ARGS --grpc_out=${GRPC_PROTO_GENS_DIR}
    --cpp_out=${GRPC_PROTO_GENS_DIR}
    --plugin=protoc-gen-grpc=${helloworld_GRPC_CPP_PLUGIN_EXECUTABLE}
    ${PROTOBUF_INCLUDE_PATH}
    ${REL_FIL}
  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
  DEPENDS ${helloworld_PROTOBUF_PROTOC_EXECUTABLE} ${helloworld_GRPC_CPP_PLUGIN_EXECUTABLE} ${ABS_FIL} )

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
)

HDFGroup/hdf5 fortran/src/CMakeLists.txt :136

add_custom_command (TARGET H5match_types POST_BUILD
    BYPRODUCTS ${HDF5_F90_BINARY_DIR}/H5f90i_gen.h ${HDF5_F90_BINARY_DIR}/H5fortran_types.F90
    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:H5match_types>
    WORKING_DIRECTORY ${HDF5_F90_BINARY_DIR}
)

HDFGroup/hdf5 fortran/src/CMakeLists.txt :143

add_custom_command (TARGET H5match_types POST_BUILD
    BYPRODUCTS ${HDF5_F90_BINARY_DIR}/static/H5f90i_gen.h ${HDF5_F90_BINARY_DIR}/static/H5fortran_types.F90
    COMMAND    ${CMAKE_COMMAND}
    ARGS       -E copy_if_different ${HDF5_F90_BINARY_DIR}/H5f90i_gen.h ${HDF5_F90_BINARY_DIR}/static/H5f90i_gen.h
    COMMAND    ${CMAKE_COMMAND}
    ARGS       -E copy_if_different ${HDF5_F90_BINARY_DIR}/H5fortran_types.F90 ${HDF5_F90_BINARY_DIR}/static/H5fortran_types.F90
    WORKING_DIRECTORY ${HDF5_F90_BINARY_DIR}/static
)

HDFGroup/hdf5 fortran/src/CMakeLists.txt :155

add_custom_command (TARGET H5match_types POST_BUILD
    BYPRODUCTS ${HDF5_F90_BINARY_DIR}/shared/H5f90i_gen.h ${HDF5_F90_BINARY_DIR}/shared/H5fortran_types.F90
    COMMAND    ${CMAKE_COMMAND}
    ARGS       -E copy_if_different ${HDF5_F90_BINARY_DIR}/H5f90i_gen.h ${HDF5_F90_BINARY_DIR}/shared/H5f90i_gen.h
    COMMAND    ${CMAKE_COMMAND}
    ARGS       -E copy_if_different ${HDF5_F90_BINARY_DIR}/H5fortran_types.F90 ${HDF5_F90_BINARY_DIR}/shared/H5fortran_types.F90
    WORKING_DIRECTORY ${HDF5_F90_BINARY_DIR}/shared
)

HDFGroup/hdf5 fortran/src/CMakeLists.txt :286

add_custom_command (TARGET H5_buildiface POST_BUILD
    BYPRODUCTS ${HDF5_F90_BINARY_DIR}/H5_gen.F90
    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:H5_buildiface>
    WORKING_DIRECTORY ${HDF5_F90_BINARY_DIR}
    COMMENT "Generating the H5_gen.F90 file"
)

HDFGroup/hdf5 fortran/src/CMakeLists.txt :293

add_custom_command (TARGET H5_buildiface POST_BUILD
    BYPRODUCTS ${HDF5_F90_BINARY_DIR}/static/H5_gen.F90
    COMMAND    ${CMAKE_COMMAND}
    ARGS       -E copy_if_different ${HDF5_F90_BINARY_DIR}/H5_gen.F90 ${HDF5_F90_BINARY_DIR}/static/H5_gen.F90
    WORKING_DIRECTORY ${HDF5_F90_BINARY_DIR}/static
    COMMENT "Generating the H5_gen.F90 file"
)

HDFGroup/hdf5 fortran/src/CMakeLists.txt :307

add_custom_command (TARGET H5_buildiface POST_BUILD
    BYPRODUCTS ${HDF5_F90_BINARY_DIR}/shared/H5_gen.F90
    COMMAND    ${CMAKE_COMMAND}
    ARGS       -E copy_if_different ${HDF5_F90_BINARY_DIR}/H5_gen.F90 ${HDF5_F90_BINARY_DIR}/shared/H5_gen.F90
    WORKING_DIRECTORY ${HDF5_F90_BINARY_DIR}/shared
    COMMENT "Generating the H5_gen.F90 shared file"
)

HDFGroup/hdf5 fortran/test/CMakeLists.txt :94

add_custom_command (TARGET H5_test_buildiface POST_BUILD
    BYPRODUCTS ${HDF5_FORTRAN_TESTS_BINARY_DIR}/static/tf_gen.F90
    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:H5_test_buildiface>
    WORKING_DIRECTORY ${HDF5_FORTRAN_TESTS_BINARY_DIR}/static
    COMMENT "Generating the tf_gen.F90 static file"
)

HDFGroup/hdf5 fortran/test/CMakeLists.txt :105

add_custom_command (TARGET H5_test_buildiface POST_BUILD
    BYPRODUCTS ${HDF5_FORTRAN_TESTS_BINARY_DIR}/shared/tf_gen.F90
    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:H5_test_buildiface>
    WORKING_DIRECTORY ${HDF5_FORTRAN_TESTS_BINARY_DIR}/shared
    COMMENT "Generating the tf_gen.F90 shared file"
)

HDFGroup/hdf5 hl/fortran/src/CMakeLists.txt :115

add_custom_command (TARGET H5HL_buildiface POST_BUILD
    BYPRODUCTS ${HDF5_HL_F90_BINARY_DIR}/static/H5LTff_gen.F90 ${HDF5_HL_F90_BINARY_DIR}/static/H5TBff_gen.F90
    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:H5HL_buildiface>
    WORKING_DIRECTORY ${HDF5_HL_F90_BINARY_DIR}/static
    COMMENT "Generating the H5LTff_gen.F90, H5TBff_gen.F90 files"
)

HDFGroup/hdf5 hl/fortran/src/CMakeLists.txt :131

add_custom_command (TARGET H5HL_buildiface POST_BUILD
    BYPRODUCTS ${HDF5_HL_F90_BINARY_DIR}/shared/H5LTff_gen.F90 ${HDF5_HL_F90_BINARY_DIR}/shared/H5TBff_gen.F90
    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:H5HL_buildiface>
    WORKING_DIRECTORY ${HDF5_HL_F90_BINARY_DIR}/shared
    COMMENT "Generating the H5LTff_gen.F90, H5TBff_gen.F90 shared files"
)

AcademySoftwareFoundation/Imath website/CMakeLists.txt :30

add_custom_command(OUTPUT ${SPHINX_INDEX_FILE}
                   COMMAND 
                     ${SPHINX_EXECUTABLE} -b html
                     # Tell Breathe where to find the Doxygen output
                     -Dbreathe_projects.Imath=${DOXYGEN_OUTPUT_DIR}/xml
                   ${SPHINX_SOURCE} ${SPHINX_BUILD}
                   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
                   DEPENDS ${DOXYGEN_INDEX_FILE}
                   MAIN_DEPENDENCY conf.py
                   COMMENT "Generating documentation with Sphinx")

ispc/ispc CMakeLists.txt :310

    add_custom_command (
        OUTPUT ${BISON_CPP_OUTPUT} ${BISON_OUTPUT}
        COMMAND ${BISON_EXECUTABLE} -d -t -v
            --output=${BISON_CPP_OUTPUT}
            ${BISON_INPUT}
        MAIN_DEPENDENCY ${BISON_INPUT}
        COMMENT "Generating parse.cc"
        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)

cmake add_custom_command(WORKING_DIRECTORY) examples