cmake examples

86Box/86Box src/CMakeLists.txt :268

add_custom_command(TARGET 86Box POST_BUILD COMMAND paxctl ARGS +m $<TARGET_FILE:86Box> COMMENT "Disable PaX MPROTECT")

ornladios/ADIOS2 cmake/ADIOSBisonFlexSub.cmake :5

ADD_CUSTOM_COMMAND(OUTPUT parser.cpp
        COMMAND ${CMAKE_COMMAND} -E copy ${BISON_FLEX_PRECOMPILE_DIR}/parser.cpp ${CMAKE_CURRENT_BINARY_DIR}
        COMMAND ${CMAKE_COMMAND} -E copy ${BISON_FLEX_PRECOMPILE_DIR}/parser.h ${CMAKE_CURRENT_BINARY_DIR}
        COMMAND ${CMAKE_COMMAND} -E copy ${BISON_FLEX_PRECOMPILE_DIR}/location.hh ${CMAKE_CURRENT_BINARY_DIR}
	COMMENT "Using pre-generated Bison Output from ${BISON_FLEX_PRECOMPILE_DIR}")

ornladios/ADIOS2 thirdparty/dill/dill/CMakeLists.txt :299

add_custom_command(OUTPUT dill_${_arch}.c 
               COMMAND ${CMAKE_COMMAND} -E copy
                   ${PROJECT_SOURCE_DIR}/pregen-source/dill_${_arch}.c dill_${_arch}.c
               COMMENT "Copying pregen diil_${_arch}.c build area")

ornladios/ADIOS2 thirdparty/ffs/ffs/cmake/BisonFlexSub.cmake :20

ADD_CUSTOM_COMMAND(OUTPUT cod.tab.c
        COMMAND ${CMAKE_COMMAND} -E copy ${BISON_FLEX_PRECOMPILE_DIR}/cod.tab.c ${CMAKE_CURRENT_BINARY_DIR}
        COMMAND ${CMAKE_COMMAND} -E copy ${BISON_FLEX_PRECOMPILE_DIR}/cod.tab.h ${CMAKE_CURRENT_BINARY_DIR}
	COMMENT "Using pre-generated Bison Output from ${BISON_FLEX_PRECOMPILE_DIR}")

ornladios/ADIOS2 thirdparty/ffs/ffs/cod/tests/CMakeLists.txt :13

add_custom_command(OUTPUT general.c
               COMMAND ${CMAKE_COMMAND} -E copy
                   ${PROJECT_SOURCE_DIR}/pregen-source/cod/tests/general.c general.c
               COMMENT "Copying pregen general.c to build area")

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)

OpenChemistry/avogadrolibs avogadro/rendering/CMakeLists.txt :127

add_custom_command(
  OUTPUT ${resh}
  DEPENDS ${src} encodefile
  COMMAND encodefile
  ARGS ${src} ${resh} ${file_we}
  COMMENT "Encoding ${src}"
  )

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

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 CMake/FindLcov.cmake :102

add_custom_command(OUTPUT "${OUTFILE}.raw"
	COMMAND cat ${ARGV} > ${OUTFILE}.raw
	DEPENDS ${ARGV}
	COMMENT "Generating ${FILE_REL}"
)

catchorg/Catch2 CMake/FindLcov.cmake :169

add_custom_command(OUTPUT ${OUTFILE} COMMAND ${GCOV_ENV} ${GENINFO_BIN}
		--quiet --base-directory ${PROJECT_SOURCE_DIR} --initial
		--gcov-tool ${GCOV_BIN} --output-filename ${OUTFILE}
		${GENINFO_EXTERN_FLAG} ${TDIR}/${FILE}.gcno
	DEPENDS ${TNAME}
	COMMENT "Capturing initial coverage data for ${FILE}"
)

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
)

projectchrono/chrono src/chrono_sensor/CMakeLists.txt :486

add_custom_command(TARGET Chrono_sensor
  PRE_BUILD
  COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/lib/sensor_ptx"
  COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_OBJECTS:Chrono_sensor_ptx> "${CMAKE_BINARY_DIR}/lib/sensor_ptx"
  COMMAND_EXPAND_LISTS
  COMMENT "Copy Chrono::Sensor PTX files."
)

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
)

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

dftbplus/dftbplus cmake/DftbPlusUtils.cmake :671

add_custom_command(TARGET lcov_eval POST_BUILD
  COMMAND ;
  COMMENT "LCOV total coverage evaluated in ${lcov_output_dir}/lcov.total")

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 addon/doxmlparser/CMakeLists.txt :2

  add_custom_command(
	  COMMENT "Updating index.py from index.xsd..."
	  COMMAND ${GENERATEDS_EXECUTABLE} --no-dates --no-versions -f -o ${PROJECT_SOURCE_DIR}/addon/doxmlparser/doxmlparser/index.py ${PROJECT_SOURCE_DIR}/templates/xml/index.xsd
	  COMMAND ${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/addon/doxmlparser/generateDS_post.py ${PROJECT_SOURCE_DIR}/addon/doxmlparser/doxmlparser/index.py ${PROJECT_SOURCE_DIR}/addon/doxmlparser/doxmlparser/index_new.py
          COMMAND ${CMAKE_COMMAND} -E remove ${PROJECT_SOURCE_DIR}/addon/doxmlparser/doxmlparser/index.py
          COMMAND ${CMAKE_COMMAND} -E rename ${PROJECT_SOURCE_DIR}/addon/doxmlparser/doxmlparser/index_new.py ${PROJECT_SOURCE_DIR}/addon/doxmlparser/doxmlparser/index.py
	  DEPENDS ${PROJECT_SOURCE_DIR}/templates/xml/index.xsd ${PROJECT_SOURCE_DIR}/addon/doxmlparser/generateDS_post.py
	  OUTPUT  ${PROJECT_SOURCE_DIR}/addon/doxmlparser/doxmlparser/index.py
  )

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)

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

embree/embree common/cmake/ispc.cmake :139

ADD_CUSTOM_COMMAND(
  OUTPUT ${results} "${ISPC_TARGET_DIR}/${fname}_ispc.h"
  COMMAND ${CMAKE_COMMAND} -E make_directory ${outdir}
  COMMAND ${EMBREE_ISPC_EXECUTABLE}
  -I "${CMAKE_CURRENT_SOURCE_DIR}"
  ${ISPC_INCLUDE_DIR_PARMS}
  ${ISPC_DEFINITIONS}
  --arch=${ISPC_ARCHITECTURE}
  --addressing=${EMBREE_ISPC_ADDRESSING}
  ${ISPC_OPT_FLAGS}
  --target=${ISPC_TARGET_ARGS}
  --woff
  --opt=fast-math
  ${ISPC_ADDITIONAL_ARGS}
  -h "${ISPC_TARGET_DIR}/${fname}_ispc.h"
  -MMM  ${outdir}/${fname}.dev.idep
  -o ${outdir}/${fname}.dev${ISPC_TARGET_EXT}
  ${input}
  DEPENDS ${input} ${deps}
  COMMENT "Building ISPC object ${outdir}/${fname}.dev${ISPC_TARGET_EXT}"
)

Exiv2/exiv2 app/CMakeLists.txt :40

add_custom_command(
  TARGET exiv2
  POST_BUILD
  COMMAND ${CMAKE_COMMAND} -E copy_directory ${PROJECT_BINARY_DIR}/conanDlls ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
  COMMENT "Copy 3rd party DLLs the bin folder"
)

FirebirdSQL/firebird builds/cmake/BuildFunctions.cmake :98

add_custom_command(
    OUTPUT ${out}
    DEPENDS gpre_boot ${in}
    COMMENT "Calling GPRE boot for ${F}"
    #
    COMMAND ${CMAKE_COMMAND} -E make_directory ${dir}
    COMMAND ${ARGN} ${in} ${out}
)

FirebirdSQL/firebird src/CMakeLists.txt :165

add_custom_command(
    OUTPUT codes_headers.dummy
    DEPENDS
        codes
        msg_fdb
    COMMENT ""
    #
    COMMAND ${CMAKE_COMMAND} -E echo "" > codes_headers.dummy
    COMMAND ${CMAKE_COMMAND} -E echo Building codes header...
    COMMAND ${CODES_CMD} ${CMAKE_CURRENT_SOURCE_DIR}/include/gen ${CMAKE_SOURCE_DIR}/lang_helpers
)

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
)

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

FluidSynth/fluidsynth cmake_admin/CodeCoverage.cmake :351

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

FluidSynth/fluidsynth cmake_admin/CodeCoverage.cmake :469

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

FreeCAD/FreeCAD cMake/FreeCadMacros.cmake :105

ADD_CUSTOM_COMMAND(
	COMMAND   "${CMAKE_COMMAND}" -E copy "${infile}" "${outfile}"
	OUTPUT    "${outfile}"
	COMMENT "Copying ${infile} to ${outfile}${fc_details}"
	MAIN_DEPENDENCY "${infile}"
)

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 data/examples/CMakeLists.txt :27

    add_custom_command(
        DEPENDS   ${it}
        OUTPUT    ${out}
        COMMAND   ${CMAKE_COMMAND}
        ARGS      -E copy_if_different ${it} ${out}
        MAIN_DEPENDENCY ${it}
        COMMENT   "Copy file to ${out}"
)

FreeCAD/FreeCAD data/examples/CMakeLists.txt :42

    add_custom_command(
        DEPENDS   ${it}
        OUTPUT    ${out}
        COMMAND   ${CMAKE_COMMAND}
        ARGS      -E copy_if_different ${it} ${out}
        MAIN_DEPENDENCY ${it}
        COMMENT   "Copy file to ${out}"
)

FreeCAD/FreeCAD data/examples/CMakeLists.txt :107

    add_custom_command(
        DEPENDS   ${it}
        OUTPUT    ${out}
        COMMAND   ${CMAKE_COMMAND}
        ARGS      -E copy_if_different ${it} ${out}
        MAIN_DEPENDENCY ${it}
        COMMENT   "Copy file to ${out}"
)

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

KDAB/GammaRay docs/manual/CMakeLists.txt :36

add_custom_command(
    OUTPUT ${_qdoc_output_dir}/${_qdocconf_name}.qhp
    COMMAND
        ${CMAKE_COMMAND} -E env QT_INSTALL_DOCS=${QDOC_TEMPLATE_DIR} QT_VERSION_TAG=${GAMMARAY_PLUGIN_VERSION}
        QT_VERSION=${GAMMARAY_VERSION} BUILDDIR=${CMAKE_CURRENT_BINARY_DIR} ${QDOC_EXECUTABLE} ${_qdoc_index_args}
        --outputdir ${_qdoc_output_dir} ${CMAKE_CURRENT_SOURCE_DIR}/${_qdocconf_name}-offline.qdocconf
    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${_qdocconf_name}-offline.qdocconf ${_qdoc_srcs} ${_qdoc_imgs}
    COMMENT "Generate the offline manual using qdoc"
)

KDAB/GammaRay docs/manual/CMakeLists.txt :47

add_custom_command(
    OUTPUT ${_qdoc_output_dir}/${_qdocconf_name}.qch
    COMMAND ${QHELPGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/${_qdocconf_name}/${_qdocconf_name}.qhp
    DEPENDS ${_qdoc_output_dir}/${_qdocconf_name}.qhp
    COMMENT "Generate the qch version of the manual using qhelpgenerator"
)

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 CMake/UseDebian.cmake :153

add_custom_command(
  OUTPUT    ${CMAKE_BINARY_DIR}/${DEBIAN_PACKAGE_NAME}_${CPACK_PACKAGE_VERSION}-1_${DEBIAN_ARCHITECTURE}.deb
  COMMAND   ${CMAKE_AR}
  ARGS      -r ${CMAKE_BINARY_DIR}/${DEBIAN_PACKAGE_NAME}_${CPACK_PACKAGE_VERSION}-1_${DEBIAN_ARCHITECTURE}.deb
  ${CMAKE_BINARY_DIR}/debian-binary
  ${CMAKE_BINARY_DIR}/control.tar.gz ${CMAKE_BINARY_DIR}/data.tar.gz
  DEPENDS   ${CMAKE_BINARY_DIR}/debian-binary ${CMAKE_BINARY_DIR}/control.tar.gz ${CMAKE_BINARY_DIR}/data.tar.gz
  COMMENT   "Generating deb package"
  )

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/Csharp/CMakeLists.txt :10

add_custom_command(
  OUTPUT ${GDCM_EXECUTABLE_DIR}/${test}.exe
  COMMAND ${CMAKE_CSHARP_COMPILER} "${CSC_PLATFORM_FLAG}" "/r:${GDCM_LIBRARY_DIR}/gdcm-sharp.dll" "/out:${GDCM_EXECUTABLE_DIR}/${test}.exe" ${result}
  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${test}.cs
  COMMENT "Create ${test}.exe"
  )

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

add_custom_command(
  OUTPUT ${GDCM_EXECUTABLE_DIR}/${test}.exe
  COMMAND ${CMAKE_CSHARP_COMPILER} "${CSC_PLATFORM_FLAG}" "/r:${GDCM_LIBRARY_DIR}/gdcm-sharp.dll" "/out:${GDCM_EXECUTABLE_DIR}/${test}.exe" ${result}
  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${test}.cs
  COMMENT "Create ${test}.exe"
  )

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/KWStyle/CMakeLists.txt :17

add_custom_command(
  OUTPUT ${GDCM_BINARY_DIR}/KWStyleReport.txt
  COMMAND ${KWSTYLE_EXECUTABLE}
  ARGS    -xml ${GDCM_BINARY_DIR}/Utilities/KWStyle/GDCM.kws.xml -o ${GDCM_SOURCE_DIR}/Utilities/KWStyle/GDCMOverwrite.txt -v ${KWSTYLE_ARGUMENTS} -D ${GDCM_BINARY_DIR}/Utilities/KWStyle/GDCMFiles.txt
  COMMENT "Coding Style Checker"
  )

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

add_custom_command(TARGET ${SWIG_MODULE_php_vtkgdcm_REAL_NAME}
  PRE_BUILD
  COMMAND sed -i -e 's/zend_error_noreturn/zend_error/g' "${swig_generated_file_fullname}"
  COMMENT "Patching zend_error_noreturn into zend_error"
  )

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

#add_custom_command(
#  OUTPUT  ${GDCM_LIBRARY_DIR}/vtkgdcm-sharp.dll.config
#  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/vtkgdcm-sharp.dll.config ${GDCM_LIBRARY_DIR}
#  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/vtkgdcm-sharp.dll.config
#  COMMENT "Copying vtkgdcm-sharp.dll.config"
#)

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/Csharp/CMakeLists.txt :14

add_custom_command(
  OUTPUT ${GDCM_EXECUTABLE_DIR}/${example}.exe
  COMMAND ${CMAKE_CSHARP_COMPILER} ARGS "/r:${ACTIVIZ_KITWARE_VTK_LIBRARY}" "/r:${ACTIVIZ_KITWARE_MUMMY_RUNTIME_LIBRARY}" "/r:${GDCM_LIBRARY_DIR}/Kitware.VTK.GDCM.dll" "/r:${GDCM_LIBRARY_DIR}/gdcm-sharp.dll" "/out:${GDCM_EXECUTABLE_DIR}/${example}.exe" ${result}
  DEPENDS ${GDCM_LIBRARY_DIR}/Kitware.VTK.GDCM.dll
  ${CMAKE_CURRENT_SOURCE_DIR}/${example}.cs
  COMMENT "Create ${example}.exe"
  )

malaterre/GDCM Utilities/VTK/Examples/Csharp/CMakeLists.txt :45

add_custom_command(
  OUTPUT ${GDCM_EXECUTABLE_DIR}/${example}.exe
  COMMAND ${CMAKE_CSHARP_COMPILER} ARGS "/r:${GDCM_LIBRARY_DIR}/vtkgdcm-sharp.dll" "/out:${GDCM_EXECUTABLE_DIR}/${example}.exe" ${result}
  DEPENDS ${GDCM_LIBRARY_DIR}/vtkgdcm-sharp.dll
  ${CMAKE_CURRENT_SOURCE_DIR}/${example}.cs
  COMMENT "Create ${example}.exe"
  )

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

malaterre/GDCM Wrapping/PHP/CMakeLists.txt :66

add_custom_command(TARGET ${SWIG_MODULE_php_gdcm_REAL_NAME}
  PRE_BUILD
  COMMAND sed -i -e 's/zend_error_noreturn/zend_error/g' "${swig_generated_file_fullname}"
  COMMENT "Patching zend_error_noreturn into zend_error"
)

geographiclib/geographiclib cmake/maintainer-man.cmake :16

add_custom_command (OUTPUT ${TOOL}.1
  COMMAND ${POD2MAN} --center=\"GeographicLib Utilities\"
  --date `date +%Y-%m-%d`
  --release=\"GeographicLib ${PROJECT_VERSION}\"
  ${CMAKE_CURRENT_SOURCE_DIR}/${TOOL}.pod > ${TOOL}.1
  COMMENT "Building man page for ${TOOL}"
  MAIN_DEPENDENCY ${TOOL}.pod)

geographiclib/geographiclib cmake/maintainer-man.cmake :23

add_custom_command (OUTPUT ${TOOL}.1.html COMMAND
  ${POD2HTML} --title "'${TOOL}(1)'"
  --noindex ${CMAKE_CURRENT_SOURCE_DIR}/${TOOL}.pod |
  sed
  -e 's%<head>%<head><link href="http://search.cpan.org/s/style.css" rel="stylesheet" type="text/css">%'
  -e 's%<code>\\\([^<>]*\\\)\(\\\(.\\\)\)</code>%<a href="\\1.\\2.html">&</a>%'g > ${TOOL}.1.html
  COMMENT "Building html version of man page for ${TOOL}"
  MAIN_DEPENDENCY ${TOOL}.pod)

geographiclib/geographiclib doc/CMakeLists.txt :57

add_custom_command (OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/html/index.html
  DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/doxyfile
    ${CMAKE_CURRENT_BINARY_DIR}/GeographicLib.dox
    ${CXXSOURCES} ${EXTRA_FILES} ${FIGURES} ${HTMLMAN}
  COMMAND ${CMAKE_COMMAND} -E copy ${HTMLMAN} html-stage
  COMMAND ${CMAKE_COMMAND} -E ${RMDIR} html
  COMMAND ${CMAKE_COMMAND} -E copy_directory html-stage html
  COMMAND ${DOXYGEN_EXECUTABLE} doxyfile > doxygen.log
  COMMENT "Generating C++ documentation tree")

geographiclib/geographiclib wrapper/c/CMakeLists.txt :29

add_custom_command (TARGET ${PROJECT_NAME} POST_BUILD
  COMMAND
    ${CMAKE_COMMAND} -E
    copy $<TARGET_FILE:${GeographicLib_LIBRARIES}> ${CMAKE_CFG_INTDIR}
  COMMENT "Installing shared library in build tree")

geographiclib/geographiclib wrapper/excel/CMakeLists.txt :42

    add_custom_command (TARGET ${PROJECT_NAME} POST_BUILD
      COMMAND
        ${CMAKE_COMMAND} -E
        copy $<TARGET_FILE:${GeographicLib_LIBRARIES}> ${CMAKE_CFG_INTDIR}
      COMMENT "Installing shared library in build tree
${INSTALL_MSG}")

geographiclib/geographiclib wrapper/python/CMakeLists.txt :37

add_custom_command (TARGET ${PROJECT_NAME} POST_BUILD
  COMMAND
    ${CMAKE_COMMAND} -E
    copy $<TARGET_FILE:${GeographicLib_LIBRARIES}> ${CMAKE_CFG_INTDIR}
  COMMENT "Installing shared library in build tree")

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

KhronosGroup/glslang StandAlone/CMakeLists.txt :40

add_custom_command(
    OUTPUT  ${GLSLANG_INTRINSIC_H}
    COMMAND Python3::Interpreter "${GLSLANG_INTRINSIC_PY}"
            "-i" ${GLSLANG_INTRINSIC_HEADER_DIR}
            "-o" ${GLSLANG_INTRINSIC_H}
    DEPENDS ${GLSLANG_INTRINSIC_PY}
    COMMENT "Generating ${GLSLANG_INTRINSIC_H}")

gnuradio/gnuradio cmake/Modules/CodeCoverage.cmake :138

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

gnuradio/gnuradio cmake/Modules/GrPybind.cmake :18

add_custom_command(
    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/docstring_status
    COMMAND
        ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/docs/doxygen/update_pydoc.py
        "sub" "--json_path"
        ${PROJECT_BINARY_DIR}/docs/doxygen/gnuradio_docstrings.json
        "--bindings_dir" ${CMAKE_CURRENT_SOURCE_DIR}/docstrings "--output_dir"
        ${CMAKE_CURRENT_BINARY_DIR} "--filter" ${filter}
    COMMENT "Adding docstrings into ${name} pybind headers ..."
    DEPENDS gnuradio_docstrings)

gnuradio/gnuradio cmake/Modules/GrPybind.cmake :31

add_custom_command(
    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/docstring_status
    COMMAND
        ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/docs/doxygen/update_pydoc.py
        "copy" "--bindings_dir" ${CMAKE_CURRENT_SOURCE_DIR}/docstrings
        "--output_dir" ${CMAKE_CURRENT_BINARY_DIR}
    COMMENT "Copying ${name} docstring templates as pybind headers ...")

gnuradio/gnuradio cmake/Modules/GrPybind.cmake :115

add_custom_command(
    OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}}/${file}
    COMMAND
        "${PYTHON_EXECUTABLE}"
        ${PROJECT_SOURCE_DIR}/gr-utils/bindtool/scripts/bind_intree_file.py
        "--output_dir" ${CMAKE_CURRENT_SOURCE_DIR}/.. "--prefix"
        ${CMAKE_INSTALL_PREFIX} "--module" ${name} "--filename"
        ${header_full_path} "--status"
        ${CMAKE_CURRENT_BINARY_DIR}/${file}.regen_status
        "--flag_automatic" ${flag_auto} "--flag_pygccxml"
        ${flag_pygccxml} "--include"
        ${extra_includes} # Use additional includes, if available
    COMMENT "Automatic generation of pybind11 bindings for "
            ${header_full_path})

gnuradio/gnuradio cmake/Modules/GrPybind.cmake :149

add_custom_command(
    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/docstring_status
    COMMAND
        ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/docs/doxygen/update_pydoc.py
        "sub" "--json_path"
        ${PROJECT_BINARY_DIR}/docs/doxygen/gnuradio_docstrings.json
        "--bindings_dir" ${CMAKE_CURRENT_SOURCE_DIR}/docstrings "--output_dir"
        ${CMAKE_CURRENT_BINARY_DIR} "--filter" ${filter}
    COMMENT "Adding docstrings into ${name} pybind headers ..."
    DEPENDS gnuradio_docstrings)

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

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

gnuradio/gnuradio cmake/Modules/GrPybind.cmake :311

add_custom_command(
    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/docstring_status
    COMMAND
        ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/docs/doxygen/update_pydoc.py
        "copy" "--bindings_dir" ${CMAKE_CURRENT_SOURCE_DIR}/docstrings
        "--output_dir" ${CMAKE_CURRENT_BINARY_DIR}
    COMMENT "Copying ${name} docstring templates as pybind headers ...")

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 :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 config/sanitizer/code-coverage.cmake :481

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

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 config/sanitizer/code-coverage.cmake :481

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

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

cmake add_custom_command(COMMENT) examples