add_custom_target(copy-${target}-def-file ALL
                          COMMAND ${CMAKE_COMMAND} -E copy_if_different ${DEF_FILE} VkLayer_${target}.def
                          VERBATIM)

add_custom_target(debug
  COMMAND ${CMAKE_COMMAND} -D CMAKE_BUILD_TYPE=Debug .
  COMMAND ${CMAKE_COMMAND} -E echo "***"
  COMMAND ${CMAKE_COMMAND} -E echo "*** Switched to Debug mode. Now recompile with: ${_make_command}"
  COMMAND ${CMAKE_COMMAND} -E echo "***"
  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  VERBATIM
  COMMENT "switching to DEBUG mode..."
  )

add_custom_target(doc ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile
		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
		COMMENT "Generating API documentation with Doxygen" VERBATIM 
	)

add_custom_target(${Coverage_NAME}

        # Cleanup fastcov
        COMMAND ${FASTCOV_PATH} ${Coverage_FASTCOV_ARGS} --gcov ${GCOV_PATH}
            --search-directory ${BASEDIR}
            --zerocounters

        COMMAND ${FASTCOV_EXEC_TESTS_CMD}
        COMMAND ${FASTCOV_CAPTURE_CMD}
        COMMAND ${FASTCOV_CONVERT_CMD}
        COMMAND ${FASTCOV_HTML_CMD}
        COMMAND ${FASTCOV_POST_CMD}

        # Set output files as GENERATED (will be removed on 'make clean')
        BYPRODUCTS
             ${Coverage_NAME}.info
             ${Coverage_NAME}.json
             ${Coverage_NAME}/index.html  # report directory

        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
        DEPENDS ${Coverage_DEPENDENCIES}
        VERBATIM # Protect arguments to commands
        COMMENT "Resetting code coverage counters to zero. Processing code coverage counters and generating report."
    )

add_custom_target(uninstall-sdl-example-apks
                COMMAND "${CMAKE_COMMAND}" "-DADB=$<TARGET_FILE:SdlAndroid::adb>" -DACTION=uninstall "-DPACKAGES=${packages}" -P "${SDL3_SOURCE_DIR}/cmake/android/SdlAndroidScript.cmake"
                VERBATIM
            )

add_custom_target(${icmaker_target}-fuse
                                  COMMAND ${AVRGCC_AVRDUDE} ${_avrdude_params} ${${icmaker_target}_AVR_FUSE}
                                  DEPENDS ${icmaker_target}.hex
                                  COMMENT "Programming ${icmaker_target}"
                                  VERBATIM)

ADD_CUSTOM_TARGET(UpdateAssimpLibsDebugSymbolsAndDLLs COMMENT "Copying Assimp Libraries ..." VERBATIM)

add_custom_target( mac_fileprovideruiplugin ALL
            xcodebuild ARCHS=${CMAKE_OSX_ARCHITECTURES} ONLY_ACTIVE_ARCH=NO
            -project ${CMAKE_SOURCE_DIR}/shell_integration/MacOSX/NextcloudIntegration/NextcloudIntegration.xcodeproj
            -target FileProviderUIExt -configuration ${XCODE_TARGET_CONFIGURATION} "SYMROOT=${CMAKE_CURRENT_BINARY_DIR}"
            "OC_APPLICATION_EXECUTABLE_NAME=${APPLICATION_EXECUTABLE}"
            "OC_APPLICATION_VENDOR=${APPLICATION_VENDOR}"
            "OC_APPLICATION_NAME=${APPLICATION_NAME}"
            "OC_APPLICATION_REV_DOMAIN=${APPLICATION_REV_DOMAIN}"
            "OC_SOCKETAPI_TEAM_IDENTIFIER_PREFIX=${SOCKETAPI_TEAM_IDENTIFIER_PREFIX}"
            DEPENDS mac_fileproviderplugin
            COMMENT building macOS File Provider UI extension
            VERBATIM)

add_custom_target(valpkg
  DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/.maja_val_pkg.stamp
  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
  COMMENT "MAJA-${MAJA_VERSION} validation package is created successfully!"
  VERBATIM
  )

add_custom_target( shellanything_doc ALL
      COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_OUT}
      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
      COMMENT "Generating API documentation with Doxygen"
      VERBATIM )

add_custom_target(sim
	  COMMAND ${CMAKE_COMMAND}
	    --build ${SIM_BINARY_DIR}
	    --config ${CMAKE_BUILD_TYPE}
	  COMMENT "Building for i386 (simulator)"
	  VERBATIM
	)

add_custom_target(doc
		${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
		DEPENDS doc_dir doxygen_dir
		WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/docs
		COMMENT "Generating API documentation with Doxygen"
		VERBATIM)

add_custom_target(doxygen 
        COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_OUT}
        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
        COMMENT "Generating API documentation with Doxygen"
        VERBATIM)

add_custom_target(update_mappings
    COMMAND "${CMAKE_COMMAND}" -P "${GLFW_SOURCE_DIR}/CMake/GenerateMappings.cmake" mappings.h.in mappings.h
    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
    COMMENT "Updating gamepad mappings from upstream repository"
    SOURCES mappings.h.in "${GLFW_SOURCE_DIR}/CMake/GenerateMappings.cmake"
    VERBATIM)

add_custom_target( doc_doxygen ALL
            COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_OUT}
            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
            COMMENT "Generating API documentation with Doxygen"
            VERBATIM )

add_custom_target(dist
    COMMAND ${CMAKE_CPACK_COMMAND} -G TGZ --config ${CMAKE_BINARY_DIR}/CPackSourceConfig.cmake
    COMMENT "Building source tarball" VERBATIM)

add_custom_target(pdfmanual
            COMMAND ${PDFMANUAL_MAKE_PROGRAM}
            COMMAND ${CMAKE_COMMAND} -E copy refman.pdf ${GNSSSDR_BINARY_DIR}/docs/GNSS-SDR_manual.pdf
            COMMAND ${PDFMANUAL_MAKE_PROGRAM} clean
            DEPENDS doc
            WORKING_DIRECTORY ${GNSSSDR_BINARY_DIR}/docs/latex
            COMMENT "Generating PDF manual with LaTeX and pdflatex..." VERBATIM
        )

add_custom_target(
        doc COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_CFG}
        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
        COMMENT "Generating API documentation with Doxygen"
        VERBATIM)

add_custom_target(list_of_test_cases
  COMMAND ls ${CMAKE_CURRENT_SOURCE_DIR}/test_suites
    | xargs -IXXX echo "class XXX : public BashTestingSuite {};"
    > test_suites.h.tmp
  COMMAND ${CMAKE_COMMAND} -E copy_if_different test_suites.h.tmp test_suites.h

  COMMAND cd ${CMAKE_CURRENT_SOURCE_DIR} && bash tools/generate_tests_from_templates.sh

  COMMAND find ${CMAKE_CURRENT_SOURCE_DIR}/test_suites/ -name test_*.sh
    ${filter_out}
    | sed -e "s/[.]sh$//"
    | awk -F/ "{print $(NF-1) \",\" $NF}"
    | xargs -IXXX echo "add_test_case(XXX)"
    > test_cases.h.tmp
  COMMAND ${CMAKE_COMMAND} -E copy_if_different test_cases.h.tmp test_cases.h

  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  VERBATIM)

add_custom_target(
    ERRMAP_H
    DEPENDS "${KRB5_ET_BIN_DIR}/errmap.h"
    VERBATIM
)

add_custom_target(test
    COMMAND ${CMAKE_CTEST_COMMAND} -j${CTEST_PARALLEL_JOBS} --output-on-failure
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    COMMENT "Running all MatX tests in parallel (${CTEST_PARALLEL_JOBS} cores)"
    VERBATIM
)

add_custom_target(vineyard_cpplint
        COMMAND ${PROJECT_SOURCE_DIR}/misc/cpplint.py --root=vineyard ${FILES_NEED_FORMAT}
        COMMENT "Running cpplint check."
        VERBATIM)

add_custom_target(GenerateNIDL_${nidlName}
            COMMAND ${PYTHON} ${NROOT}/fips-files/generators/NIDL.py "${f_abs}" "${abs_output_folder}/${out_cs}" "--csharp"
            BYPRODUCTS "${abs_output_folder}${out_cs}"
            COMMENT "IDLC: Generating ${out_cs}..."
            DEPENDS ${NROOT}/fips-files/generators/NIDL.py
            WORKING_DIRECTORY "${NROOT}"
            VERBATIM
            SOURCES "${f_abs}"
        )

add_custom_target(run-clang-tidy
                ${Python_EXECUTABLE} ${RUN_CLANG_TIDY} -p=${CMAKE_BINARY_DIR} -j ${NPROC} -quiet
                USES_TERMINAL
                VERBATIM)

ADD_CUSTOM_TARGET (doc_python
        ${CMAKE_COMMAND} -E echo
        "Cannot generate Python documentation for vigranumpy. "
        "(sphinx-build not found)"
        VERBATIM)

ADD_CUSTOM_TARGET(${COPY_TARGET_NAME} ALL
                      COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_SONAME_FILE:${target_name}> ${destination}/$<TARGET_SONAME_FILE_NAME:${target_name}>
                      DEPENDS ${target_name}
                      VERBATIM)

add_custom_target(
  import_test_models
  COMMAND "${CMAKE_SOURCE_DIR}/venv/bin/python" "-c" "from amici.testing.models import import_test_models; import_test_models()"
  VERBATIM
)

add_custom_target(pydoc ALL
                      ${SPHINX_EXECUTABLE}
                      -q -b html
                      -c "${BINARY_BUILD_DIR}"
                      -d "${SPHINX_CACHE_DIR}"
                      "${SPHINX_BUILD_DIR}"
                      "${SPHINX_HTML_DIR}"
                      COMMENT "Building HTML documentation with Sphinx" VERBATIM
                      DEPENDS hal::py copy_sphinx_doc_files)

add_custom_target(${target_name}
      COMMAND ${build_runtime_cmd}
      DEPENDS ${name}-configure
      WORKING_DIRECTORY ${BINARY_DIR}
      VERBATIM
      USES_TERMINAL)

add_custom_target(translations_update
    ${GETTEXT_XGETTEXT_EXECUTABLE}
      "--directory=${PROJECT_SOURCE_DIR}"
      "--output=${CMAKE_CURRENT_SOURCE_DIR}/tigervnc.pot"
      --default-domain=tigervnc
      --from-code=UTF-8
      --keyword=_
      --keyword=p_:1c,2
      --keyword=N_
      "--copyright-holder=TigerVNC team and many others \(see README.rst\)"
      --msgid-bugs-address=tigervnc-devel@googlegroups.com
      --sort-by-file
      --add-location
      --add-comments=TRANSLATORS
      ${po_source}
    COMMENT "Updating tigervnc.pot"
    VERBATIM
  )

add_custom_target(
  nanovdb_docs
  SOURCES doxygen-config
          doc.md
          codingstyle.txt
          FAQ.md
          SourceTree.md
          HowToBuild.md
          HelloWorld.md
  COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/cmake-doxygen-config
  WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
  COMMENT "Generating API documentation with Doxygen"
  VERBATIM)

add_custom_target(
  yapf
  ${CMAKE_SOURCE_DIR}/tools/yapf.sh ${CMAKE_SOURCE_DIR}
  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
  COMMENT "formatting python files"
  VERBATIM
)

add_custom_target(
    configure_ycm
    COMMAND ${CMAKE_COMMAND} -E copy ${build_dir_file} ${source_dir_file}
    COMMENT "Copying YCM config file to source directory"
    VERBATIM
  )

add_custom_target(doc ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
		WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
		COMMENT "Generating API documentation with Doxygen" VERBATIM
		DEPENDS codegen
	)

add_custom_target(AVX2 COMMENT "build AVX2 code" VERBATIM)

add_custom_target(doxygen-cling
    COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/doxygen.cfg
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    COMMENT "Generating cling doxygen documentation." VERBATIM)

add_custom_target(
    ${Coverage_NAME}
    COMMAND ${GCOVR_XML_EXEC_TESTS_CMD}
    COMMAND ${GCOVR_XML_CMD}
    BYPRODUCTS ${Coverage_NAME}.xml
    WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
    DEPENDS ${Coverage_DEPENDENCIES}
    VERBATIM # Protect arguments to commands
    COMMENT "Running gcovr to produce Cobertura code coverage report.")

add_custom_target("${_targetName}" WORKING_DIRECTORY "${CMAKE_BINARY_DIR}" VERBATIM)

add_custom_target(manpages ALL
                      ${GZIP_TOOL} -n -c9 webcamoid.1 > webcamoid.1.gz
                      DEPENDS src/webcamoid.1
                      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/src
                      BYPRODUCTS src/webcamoid.1.gz
                      VERBATIM
                      SOURCES src/webcamoid.1.in)

add_custom_target(${runtime}
      COMMAND ${build_runtime_cmd}
      DEPENDS compiler-rt-configure
      WORKING_DIRECTORY ${COMPILER_RT_BINARY_DIR}
      VERBATIM)

ADD_CUSTOM_TARGET(
    doxygen
    COMMAND ${CMAKE_COMMAND}
    -DDOXYGEN_EXECUTABLE=${DOXYGEN_EXECUTABLE}
    -DDOXYGEN_DOT_EXECUTABLE=${DOXYGEN_DOT_EXECUTABLE}
    -DDOXYFILE=${CMAKE_BINARY_DIR}/Doxyfile
    -DERROR_FILE=${CMAKE_BINARY_DIR}/doxyerror.log
    -DOUTPUT_FILE=${CMAKE_BINARY_DIR}/doxyoutput.log
    -DREDIRECT_DOXYGEN_STDOUT=${REDIRECT_DOXYGEN_STDOUT}
    -DSOURCE_DIR=${CMAKE_SOURCE_DIR}
    -DTOFIX_FILE=${CMAKE_BINARY_DIR}/tofix-all.log
    -DREGRESSION_FILE=${CMAKE_BINARY_DIR}/tofix-regressions.log
    -DIGNORE_FILE=${CMAKE_SOURCE_DIR}/Doxyfile-ignored
    -P ${CMAKE_SOURCE_DIR}/run_doxygen.cmake
    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
    COMMENT "Generating Doxygen documentation" VERBATIM
    )

add_custom_target (
            genarate_api_reference ${DOXYGEN_EXECUTABLE} ${PROJECT_BINARY_DIR}/appleseed.doxyfile
            WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
            VERBATIM
        )

add_custom_target(dxcompiler 
	COMMAND "${CMAKE_COMMAND}" --build "${DXC_BUILD_DIR}" --target dxcompiler --config $<IF:$<CONFIG:Debug>,Debug,Release> -j${_NBL_JOBS_AMOUNT_}
	BYPRODUCTS "${DXC_LIB}" "${DXC_DLL}"
	VERBATIM
	COMMAND_EXPAND_LISTS
)

ADD_CUSTOM_TARGET(fastcov-html
  COMMAND genhtml -o code_coverage report.info
  COMMENT "Running genhtml -o code_coverage report.info"
  VERBATIM
  )

add_custom_target(coretool_lrelease
                    COMMAND Qt6::lrelease ${TRANSLATIONS}
                    DEPENDS coretool_lupdate
                    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
                    VERBATIM
                    USES_TERMINAL)

add_custom_target(${_cleanTargetName}
			COMMAND ${_cmds}
			WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
			COMMENT "Cleaning up target ${_target} cotire generated files"
			VERBATIM)

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

add_custom_target(lint DEPENDS ${LINT_TARGETS} VERBATIM)

add_custom_target(${casename}
        COMMAND ${ARGN}
        VERBATIM
        COMMENT "${_c4_prefix}: running benchmark ${casename}: ${ARGN}")

add_custom_target (
          ${TARGET_UID} ${_ALL}
          COMMAND "${CMAKE_COMMAND}"
              "-DCOMMAND=${Subversion_SVN_EXECUTABLE};log"
              "-DWORKING_DIRECTORY=${PROJECT_SOURCE_DIR}"
              "-DOUTPUT_FILE=${CHANGELOG_FILE}"
              -P "${BASIS_SCRIPT_EXECUTE_PROCESS}"
          COMMAND "${CMAKE_COMMAND}"
              "-DCHANGELOG_FILE:FILE=${CHANGELOG_FILE}" -DINPUTFORMAT=SVN
              -P "${BASIS_MODULE_PATH}/PostprocessChangeLog.cmake"
          COMMENT "Generating ChangeLog from Subversion log..."
          VERBATIM
        )

add_custom_target(doc_doxygen ALL
      COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_OUT}
      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
      COMMENT "Generating API documentation with Doxygen"
      VERBATIM )

add_custom_target(${DOC_TARGET}_open
					COMMAND ${DOXYGEN_LAUNCHER_COMMAND} "${OUTPUT_DIRECTORY}/html/index.html"
					VERBATIM)

add_custom_target(${module_target}_headersclean_check
        COMMENT "headersclean: Checking headers in ${module}"
        DEPENDS ${hclean_artifacts}
        VERBATIM)

add_custom_target(${test_suite}
      COMMAND ${run_test_suite}
      DEPENDS compiler-rt-build ${COMPILER_RT_TEST_DEPENDENCIES}
      WORKING_DIRECTORY ${COMPILER_RT_BINARY_DIR}
      VERBATIM)

ADD_CUSTOM_TARGET(${_cc_project}-coverage-zero-counters
                        COMMAND find . -name *.gcda -exec rm {} \;
                        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
                        COMMENT "Zeroing coverage counters for objects in ${CMAKE_CURRENT_BINARY_DIR}"
                        VERBATIM)

add_custom_target(doxygen-llvm
    COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/doxygen.cfg
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    COMMENT "Generating llvm doxygen documentation." VERBATIM)

add_custom_target(check_format
		COMMAND scripts/format.sh ${astyle_exe} 0
		WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
		DEPENDS ${astyle_exe}
		VERBATIM
	)

add_custom_target(BUILD_DATA_SAMPLE ALL DEPENDS
    "${ozz_media_directory}/bin/arnaud_mesh.ozz"
    "${ozz_media_directory}/bin/arnaud_mesh_4.ozz"
    "${ozz_media_directory}/bin/ruby_mesh.ozz"
    "${ozz_media_directory}/bin/floor.ozz"
    VERBATIM)

add_custom_target(generate-message-map
    COMMAND "$<TARGET_FILE:vcpkg>" z-generate-default-message-map locales/messages.json "${VCPKG_ARTIFACTS_SOURCE_DIR}/locales/messages.json"
    DEPENDS ${GENERATE_MESSAGE_MAP_DEPENDENCIES}
    WORKING_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}"
    COMMENT "Update locales/messages.json"
    VERBATIM
)

ADD_CUSTOM_TARGET(target${stestnamenodot}cpp
    #The first two expressions below are for older clang
    COMMAND C_INCLUDE_PATH=${LibClang_INCLUDE_DIR}   CPLUS_INCLUDE_PATH=${LibClang_INCLUDE_DIR}  ${CMAKE_BINARY_DIR}/source/binder --bind ""  -max-file-size=100000
      --root-module ${stestnamenodot} --prefix ${CMAKE_CURRENT_BINARY_DIR}/ ${${stestname}_config_flag} --single-file  --annotate-includes  ${CMAKE_CURRENT_BINARY_DIR}/${stestname}.hpp.include ${${stestname}_cli_flags}
      -- -x c++ -std=c++11   -I . -I ${CMAKE_CURRENT_SOURCE_DIR}  -isystem /  -I ${CLANG_INCLUDE_DIRS}   -iwithsysroot${LibClang_INCLUDE_DIR}
      WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" VERBATIM)

add_custom_target(spec-all ALL
            ${BASH_COMMAND} ./makeAllExts all
            WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/specification"
            VERBATIM
            COMMENT "Running './makeAllExts all' in the specification directory"
            USES_TERMINAL)

add_custom_target(${DOC_TARGET}_open
					COMMAND ${DOXYGEN_LAUNCHER_COMMAND} "${OUTPUT_DIRECTORY}/html/index.html"
					VERBATIM)

add_custom_target(install-sdl-example-apks
                DEPENDS ${install_targets}
                VERBATIM
            )

add_custom_target(
		data_music_empackage ALL
		${Python3_EXECUTABLE} "${EMSCRIPTEN_FILE_PACKAGER_PY}" warzone2100-music.data --preload "${CMAKE_CURRENT_BINARY_DIR}/music_staging@/data/music/" --js-output=warzone2100-music.js --use-preload-cache --indexedDB-name=EM_PRELOAD_MUSIC_CACHE --no-node
		WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/empackaged/music"
		VERBATIM
	)

add_custom_target(run_${_target}
         ${_target} -v
         DEPENDS ${_target}
         COMMENT "Execute ${_target} test"
         VERBATIM
         )

add_custom_target(docs ALL
    COMMAND ${DOXYGEN_EXECUTABLE}
    VERBATIM
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/docs
    DEPENDS SimpleAmqpClient
    COMMENT "Generating API documentation"
    SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in
    )

add_custom_target(${Coverage_NAME}
        COMMAND ${LCOV_CLEAN_CMD}
        COMMAND ${LCOV_BASELINE_CMD} 
        COMMAND ${LCOV_EXEC_TESTS_CMD}
        COMMAND ${LCOV_CAPTURE_CMD}
        COMMAND ${LCOV_BASELINE_COUNT_CMD}
        COMMAND ${LCOV_FILTER_CMD} 
        COMMAND ${LCOV_GEN_HTML_CMD}

        # Set output files as GENERATED (will be removed on 'make clean')
        BYPRODUCTS
            ${Coverage_NAME}.base
            ${Coverage_NAME}.capture
            ${Coverage_NAME}.total
            ${Coverage_NAME}.info
            ${Coverage_NAME}/index.html
        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
        DEPENDS ${Coverage_DEPENDENCIES}
        VERBATIM # Protect arguments to commands
        COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
    )

add_custom_target(
    untar_seeds
    COMMAND ${CMAKE_COMMAND} -E echo "Untar fuzz seeds from ${BOOST_BEAST_FUZZER_SEEDS_PATH} to ${BOOST_BEAST_FUZZER_SEEDS_PARENT_DIR}/seeds"
    COMMAND ${CMAKE_COMMAND} -E tar xf ${BOOST_BEAST_FUZZER_SEEDS_PATH}
    WORKING_DIRECTORY ${BOOST_BEAST_FUZZER_SEEDS_PARENT_DIR}
    COMMENT "Unzipping fuzz seeds"
    VERBATIM)

add_custom_target(doc
      ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
      COMMENT "Generating API documentation with Doxygen.." VERBATIM)

add_custom_target(
  coverage-show
  DEPENDS rstest
  COMMAND "${LLVMCOV_PATH}" show -Xdemangler=$<TARGET_FILE:demangler> -instr-profile "${RAWSPEED_PROFDATA_FILE}" "$<TARGET_FILE:rstest>" -format html -output-dir "${CMAKE_BINARY_DIR}/coverage"
  COMMAND "${CMAKE_COMMAND}" -E echo "Use $$ sensible-browser \"./coverage/index.html\" to view the coverage report."
  WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
  COMMENT "Running llvm-cov tool on the *.profdata file to generate HTML coverage report"
  VERBATIM
)

add_custom_target(docs COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_config_file}
                       WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
                       COMMENT "Launching doxygen..." VERBATIM)

add_custom_target(Doxygen ALL
    COMMAND ${DOXYGEN_EXECUTABLE} ${doxyfile}
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    COMMENT "Generating API documentation with Doxygen"
    VERBATIM)

add_custom_target(
        pipenv-sync
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        VERBATIM USES_TERMINAL
        COMMAND pipenv sync
    )

add_custom_target(${TARGET}
        COMMAND ${CMAKE_COMMAND} -E chdir
                ${CMAKE_CURRENT_SOURCE_DIR}
                ${CLANG_TIDY_EXECUTABLE}
                "-quiet"
                "-header-filter=${CMAKE_CURRENT_SOURCE_DIR}/include"
                "--format-style=file"
                "--fix"
                "-p=${CMAKE_CURRENT_BINARY_DIR}"
                ${INPUT}
        COMMENT "Running ${TARGET}"
        VERBATIM)

add_custom_target (doc "${DOXYGEN_EXECUTABLE}" "${PROJECT_BINARY_DIR}/Doxyfile"
                           WORKING_DIRECTORY "${PROJECT_BINARY_DIR}"
                           COMMENT "Generate docs using Doxygen" VERBATIM)

add_custom_target(${PROJECT_NAME}_tidy
                COMMAND "${CLANG_TIDY_BIN}" ${CLANG_TIDY_FULL_ARGS}
                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
                COMMENT "Running clang-tidy for target '${PROJECT_NAME}'..."
                #VERBATIM # option prevents warning output in console if used here...
            )

add_custom_target(SlicerGenerateExtensionTemplates
  ${_extension_template_generator_commands}
  WORKING_DIRECTORY ${_template_dir}
  COMMENT "Generating extension testing templates"
  VERBATIM
  )

add_custom_target(doc_${OUTPUT_LANGUAGE} ALL
                ${DOXYGEN_EXECUTABLE} ${CMAKE_BINARY_DIR}/Doxyfile_${OUTPUT_LANGUAGE} # &> doxygen.log
                WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
                COMMENT "Generating API documentation with Doxygen" VERBATIM
                )

add_custom_target(install_requirements ALL
        COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_LIST_DIR}/install_requirements.py" "--skip_depthai" "--install_rerun" "--install_open3d_cpu"
        DEPENDS ${TARGET_NAME}
        VERBATIM
        COMMAND_EXPAND_LISTS
    )

add_custom_target("${_targetName}"
			WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
			VERBATIM)

add_custom_target(UpdateAssimpLibsDebugSymbolsAndDLLs COMMENT "Copying Assimp Libraries ..." VERBATIM)

add_custom_target(doc
    COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile
    COMMENT "Generating API documentation with Doxygen"
#     DEPENDS benchmarks
    VERBATIM
)

add_custom_target(stdgpu_doc
                 # Pre. Clean previous build
                 COMMAND ${CMAKE_COMMAND} -E rm -Rf "${STDGPU_SPHINX_OUTPUT_DIR}" "${STDGPU_SPHINX_DOXYGEN_DIR}"
                 # 1. Run Doxygen
                 COMMAND Doxygen::doxygen "${STDGPU_DOXYFILE}"
                 # 2. Run Doxysphinx
                 COMMAND ${STDGPU_DOXYSPHINX} build "${CMAKE_CURRENT_SOURCE_DIR}" "${STDGPU_SPHINX_OUTPUT_DIR}" "${STDGPU_SPHINX_DOXYGEN_DIR}"
                 # 2.1. Remove unused main page
                 COMMAND ${CMAKE_COMMAND} -E rm "${STDGPU_SPHINX_DOXYGEN_DIR}/index.rst"
                 # 2.2. Fix Doxysphinx files
                 COMMAND Python::Interpreter "${CMAKE_CURRENT_SOURCE_DIR}/fix_html_titles"
                 # 3. Run Sphinx
                 COMMAND ${STDGPU_SPHINX} "-b" "html" ${STDGPU_SPHINX_FORCE_BUILDING} ${STDGPU_SPHINX_PARALLEL} "${CMAKE_CURRENT_SOURCE_DIR}" "${STDGPU_SPHINX_OUTPUT_DIR}"
                 COMMENT "Generating stdgpu documentation"
                 VERBATIM)

add_custom_target(doc
        ${DOXYGEN_EXECUTABLE}
        ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
        COMMENT "Generating API documentation with Doxygen" VERBATIM
    )

add_custom_target(docs
    COMMAND ${DOXYGEN_EXECUTABLE} ${doxyfile}
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    COMMENT "Generating API documentation with Doxygen"
    VERBATIM)

ADD_CUSTOM_TARGET(show_build_id ALL
      COMMAND $<TARGET_FILE:mysqld> --no-defaults --help | grep BuildID
      COMMENT "Showing mysqld build id"
      VERBATIM
      )

ADD_CUSTOM_TARGET(
    doxygen
    COMMAND ${CMAKE_COMMAND}
    -DDOXYGEN_EXECUTABLE=${DOXYGEN_EXECUTABLE}
    -DDOXYGEN_DOT_EXECUTABLE=${DOXYGEN_DOT_EXECUTABLE}
    -DDOXYFILE=${CMAKE_BINARY_DIR}/Doxyfile
    -DERROR_FILE=${CMAKE_BINARY_DIR}/doxyerror.log
    -DOUTPUT_FILE=${CMAKE_BINARY_DIR}/doxyoutput.log
    -DREDIRECT_DOXYGEN_STDOUT=${REDIRECT_DOXYGEN_STDOUT}
    -DSOURCE_DIR=${CMAKE_SOURCE_DIR}
    -DTOFIX_FILE=${CMAKE_BINARY_DIR}/tofix-all.log
    -DREGRESSION_FILE=${CMAKE_BINARY_DIR}/tofix-regressions.log
    -DIGNORE_FILE=${CMAKE_SOURCE_DIR}/Doxyfile-ignored
    -P ${CMAKE_SOURCE_DIR}/run_doxygen.cmake
    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
    COMMENT "Generating Doxygen documentation" VERBATIM
    )

add_custom_target(clickhouse-stripped ALL
    COMMAND "${STRIP_PATH}" -o "${CMAKE_CURRENT_BINARY_DIR}/clickhouse-stripped" --strip-debug --remove-section=.comment --remove-section=.note "${CMAKE_CURRENT_BINARY_DIR}/clickhouse"
    DEPENDS clickhouse
    COMMENT "Stripping clickhouse binary" VERBATIM)

add_custom_target(tiglPython ALL
			COMMENT "Create python interface for tigl" VERBATIM 
			DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/tigl3wrapper.py
		)

add_custom_target(docs COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_config_file}
                       WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
                       COMMENT "Launching doxygen..." VERBATIM)

add_custom_target(coverage-${TARGET}
		DEPENDS coverage-baseline ${TARGET}
		COMMENT "Generating ${TARGET} coverage report"
		COMMAND "${CMAKE_BINARY_DIR}/Coverage-${TARGET}.sh"
		VERBATIM USES_TERMINAL
	)

add_custom_target(debug
        COMMAND ${CMAKE_COMMAND} -DCMAKE_BUILD_TYPE=Debug ${CMAKE_SOURCE_DIR}
        COMMAND ${CMAKE_COMMAND} -E echo "***"
        COMMAND ${CMAKE_COMMAND} -E echo "*** Switched to Debug mode. Now recompile with: ${_make_command}"
        COMMAND ${CMAKE_COMMAND} -E echo "***"
        COMMENT "Switching CMAKE_BUILD_TYPE to Debug"
        VERBATIM
        )

add_custom_target(${_cleanTargetName}
			COMMAND ${_cmds}
			WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
			COMMENT "Cleaning up target ${_target} cotire generated files"
			VERBATIM)

add_custom_target(doc ALL
        COMMENT "Generated project documentation" VERBATIM)

add_custom_target(doc
    COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    COMMENT "Generating API documentation with Doxygen"
    VERBATIM
    )

add_custom_target(doc_muelu
TRILINOS_HOME=${PROJECT_SOURCE_DIR} ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
COMMENT "Generating ${PACKAGE_NAME} API documentation with Doxygen" VERBATIM
)

add_custom_target(
        qemu-tests
        ${qemu_command}
        -append "${qemu_kernel_args} quiet post-init=/mnt/workspace/cmake/qemu_run_tests.sh"
        DEPENDS "${CMAKE_BINARY_DIR}/cmake/qemu_run_tests.sh"
        VERBATIM
        USES_TERMINAL
    )

add_custom_target(
  outputexports
  COMMAND echo CC="${CMAKE_C_COMPILER}"
  COMMAND echo Z_CFLAGS=${system_includes} ${includes} ${definitions} ${options}
  COMMAND echo NOSTDINC_FLAGS=${system_includes}
  COMMAND echo ZEPHYRINCLUDE=${includes}
  COMMAND echo KBUILD_CFLAGS=${definitions} ${options}
  VERBATIM
  USES_TERMINAL
)

ADD_CUSTOM_TARGET(${_target} ${_commands} VERBATIM)

ADD_CUSTOM_TARGET(NDB_MSI
		COMMAND "${CMAKE_COMMAND}" -E copy "${CPACK_PACKAGE_FILE_NAME}.msi" "${CMAKE_BINARY_DIR}/packaging/WiX/${CPACK_PACKAGE_FILE_NAME}.msi"
		DEPENDS "${CPACK_PACKAGE_FILE_NAME}.msi"
		COMMENT "Create msi for NDB"
		VERBATIM)