add_custom_command(
  OUTPUT dill_${_arch}.c vm_include.c
  COMMAND ${PERL_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${_arch}.ops
  DEPENDS ${_arch}.ops
)

add_custom_command(
  OUTPUT dill_${_arch}.c
  COMMAND ${PERL_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${_arch}.ops
  DEPENDS ${_arch}.ops
)

add_custom_command(
  OUTPUT dill.h dill.c
  COMMAND ${PERL_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/base.ops ${BASE_OPS_ARG}
  DEPENDS base.ops
)

add_custom_command(
    OUTPUT ${jnilib}
    DEPENDS ${lib}
    COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${lib}> ${jnilib})

add_custom_command(
    OUTPUT ${native}
    DEPENDS ${prog}
    COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${prog}> ${native}
    )

add_custom_command(
    OUTPUT luajit_protos
    DEPENDS ${SOURCES}
    COMMAND Python::Interpreter ${PROJECT_SOURCE_DIR}/python/checkdocs.py
        -c ${CMAKE_C_COMPILER}
        -p luajit_protos
        -b ${PROJECT_BINARY_DIR}
        -s ${PROJECT_SOURCE_DIR}
        -w
    )

add_custom_command(
    OUTPUT ${SEARCH_INDEX_JS}
    DEPENDS ${HTML_REFS_TIMESTAMP} make_search_index
    COMMAND ${MAKE_SEARCH_INDEX} ${HTML_REFS} > ${SEARCH_INDEX_JS}
    )

add_custom_command(
    OUTPUT ${HTML_DIR}/${page}.html
    DEPENDS
        ${PROTOS_TIMESTAMP}
        ${HTML_REFS_TIMESTAMP}
        ${page_src}
        ${CMAKE_CURRENT_BINARY_DIR}/inc.a.html
        ${CMAKE_CURRENT_BINARY_DIR}/inc.z.html
        ${SEARCH_INDEX_JS}
        ${API_EXAMPLES}
        make_doc
        insert_timestamp
    COMMAND
        ${INSERT_TIMESTAMP} ${CMAKE_SOURCE_DIR}/include/allegro5/base.h > inc.timestamp.html
    COMMAND
        ${MAKE_DOC}
        --examples ${API_EXAMPLES}
        --to html
        --raise-sections
        --include-before-body inc.a.html
        --include-after-body inc.timestamp.html
        --include-after-body inc.z.html
        --css pandoc.css
        --include-in-header ${SRC_DIR}/custom_header.html
        --standalone
        --toc
        -- ${page_src} ${HTML_REFS}
        > ${HTML_DIR}/${page}.html
    )

add_custom_command(
    OUTPUT ${HTML_DIR}/images/${image}.png
    DEPENDS
        ${SRC_REFMAN_DIR}/images/${image}.png
    COMMAND
        "${CMAKE_COMMAND}" -E copy
        "${SRC_REFMAN_DIR}/images/${image}.png" "${HTML_DIR}/images/${image}.png"
    )

add_custom_command(
    OUTPUT ${TEXI_DIR}/refman.texi
    DEPENDS ${PROTOS_TIMESTAMP} ${TITLE_TXT} ${PAGES_TXT}
            make_doc
    COMMAND ${MAKE_DOC}
            --to texinfo
            --standalone
            --
            ${TITLE_TXT} ${PAGES_TXT}
            > ${TEXI_DIR}/refman.texi
    )

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

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

add_custom_command(OUTPUT ${GRPC_STATIC_LIBRARY_GRPCPP_FOR_AR}
                   COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:gRPC::grpc++>
                           ${GRPC_STATIC_LIBRARY_GRPCPP_FOR_AR}
                   DEPENDS grpc_ep)

add_custom_command(OUTPUT ${PERF_PROTO_GENERATED_FILES}
                   COMMAND ${ARROW_PROTOBUF_PROTOC} "-I${CMAKE_CURRENT_SOURCE_DIR}"
                           "--cpp_out=${CMAKE_CURRENT_BINARY_DIR}" "perf.proto"
                   DEPENDS ${PROTO_DEPENDS})

add_custom_command(OUTPUT ${GANDIVA_PRECOMPILED_BC_PATH}
                   COMMAND ${LLVM_LINK_EXECUTABLE} -o ${GANDIVA_PRECOMPILED_BC_PATH}
                           ${GANDIVA_PRECOMPILED_BC_FILES}
                   DEPENDS ${GANDIVA_PRECOMPILED_BC_FILES})

add_custom_command(OUTPUT ${GANDIVA_PRECOMPILED_CC_PATH}
                   COMMAND ${PYTHON_EXECUTABLE}
                           "${CMAKE_CURRENT_SOURCE_DIR}/../make_precompiled_bitcode.py"
                           ${GANDIVA_PRECOMPILED_CC_IN_PATH}
                           ${GANDIVA_PRECOMPILED_BC_PATH} ${GANDIVA_PRECOMPILED_CC_PATH}
                   DEPENDS ${GANDIVA_PRECOMPILED_CC_IN_PATH}
                           ${GANDIVA_PRECOMPILED_BC_PATH})

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)

add_custom_command(OUTPUT build COMMAND ${PYTHON_EXECUTABLE} setup.py build DEPENDS ${PYTHON_SRC} ${PYTHON_HDR} setup.py)

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

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

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

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

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

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

ADD_CUSTOM_COMMAND(
	OUTPUT ${BULLET_PHYSICS_SOURCE_DIR}/src/LinearMath/btSerializer64.cpp
	COMMAND ${CMAKE_CFG_INTDIR}/makesdna ${BULLET_PHYSICS_SOURCE_DIR}/src/LinearMath/btSerializer64.cpp ${BULLET_PHYSICS_SOURCE_DIR}/Extras/Serialize/CommonSerialize/
	DEPENDS makesdna
)

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
)

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

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

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

  add_custom_command(
    OUTPUT ccache.1
    # Convert monospace to bold since that's typically rendered better when
    # viewing the man page.
    COMMAND perl -pe "'s!\\\\f\\(CR(.*?)\\\\fP!\\\\fB\\1\\\\fP!g'" ccache.1.tmp >ccache.1
    MAIN_DEPENDENCY ccache.1.tmp
  )
  install(
    FILES "${CMAKE_CURRENT_BINARY_DIR}/ccache.1"
    DESTINATION "${CMAKE_INSTALL_MANDIR}/man1"
  )
  add_custom_target(doc-man-page DEPENDS ccache.1)

  add_custom_target(doc ALL DEPENDS doc-html doc-man-page)
endif()

add_custom_command (OUTPUT ${_outfile}
    COMMAND ${QT_RCC_EXECUTABLE}
    ARGS -o ${_outfile}  ${_abs_FILE}
    DEPENDS ${_abs_FILE})

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

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

add_custom_command(
    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/codebookge.c
    COMMAND generate_codebook ge_cb ${CODEBOOKSGE} > ${CMAKE_CURRENT_BINARY_DIR}/codebookge.c
    DEPENDS generate_codebook ${CODEBOOKSGE}
)

add_custom_command(
    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/codebookd.c
    COMMAND generate_codebook lsp_cbd ${CODEBOOKSD} > ${CMAKE_CURRENT_BINARY_DIR}/codebookd.c
    DEPENDS generate_codebook ${CODEBOOKSD}
)

add_custom_command(
    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/codebookjmv.c
    COMMAND generate_codebook lsp_cbjmv ${CODEBOOKSJMV} > ${CMAKE_CURRENT_BINARY_DIR}/codebookjmv.c
    DEPENDS generate_codebook ${CODEBOOKSJMV}
)

add_custom_command(
    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/codebookge.c
    COMMAND generate_codebook ge_cb ${CODEBOOKSGE} > ${CMAKE_CURRENT_BINARY_DIR}/codebookge.c
    DEPENDS generate_codebook ${CODEBOOKSGE}
)

add_custom_command(
    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/codebooknewamp2_energy.c
    COMMAND generate_codebook newamp2_energy_cb ${CODEBOOKSNEWAMP2_ENERGY} > ${CMAKE_CURRENT_BINARY_DIR}/codebooknewamp2_energy.c
    DEPENDS generate_codebook ${CODEBOOKSNEWAMP2_ENERGY}
)

add_custom_command(
    # The AsmOffsetsPortable.cs is consumed later by the managed build
    TARGET PortableRuntime
    COMMAND ${CMAKE_CXX_COMPILER} ${COMPILER_LANGUAGE} ${DEFINITIONS} ${PREPROCESSOR_FLAGS} -I"${ARCH_SOURCES_DIR}" "${ASM_OFFSETS_CSPP}" >"${CMAKE_CURRENT_BINARY_DIR}/AsmOffsetsPortable.cs"
    DEPENDS "${RUNTIME_DIR}/AsmOffsets.cpp" "${RUNTIME_DIR}/AsmOffsets.h"
)

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

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
)

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
)

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
)

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

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

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

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

add_custom_command(
  OUTPUT "${of}"
  COMMAND ${Python_EXECUTABLE} ${FYPP_EXECUTABLE} ARGS "-F" "${f}" "${of}"
  DEPENDS "${f}")

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)

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)

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)

  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
  )

add_custom_command(
    COMMAND ${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/src/pre_lex.py ${PROJECT_SOURCE_DIR}/addon/doxywizard/${lex_file}.l  ${GENERATED_SRC_WIZARD}/${lex_file}.l ${GENERATED_SRC_WIZARD}/${lex_file}.corr ${GENERATED_SRC_WIZARD}/${lex_file}.d ${PROJECT_SOURCE_DIR}/src
    DEPENDS ${PROJECT_SOURCE_DIR}/src/pre_lex.py ${PROJECT_SOURCE_DIR}/addon/doxywizard/${lex_file}.l
    DEPFILE ${GENERATED_SRC_WIZARD}/${lex_file}.d
    OUTPUT  ${GENERATED_SRC_WIZARD}/${lex_file}.l ${GENERATED_SRC_WIZARD}/${lex_file}.corr ${GENERATED_SRC_WIZARD}/${lex_file}.d
)

add_custom_command(
    COMMAND ${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/src/pre_lex.py ${PROJECT_SOURCE_DIR}/addon/doxywizard/${lex_file}.l  ${GENERATED_SRC_WIZARD}/${lex_file}.l ${GENERATED_SRC_WIZARD}/${lex_file}.corr ${GENERATED_SRC_WIZARD}/${lex_file}.d ${PROJECT_SOURCE_DIR}/src
    DEPENDS ${PROJECT_SOURCE_DIR}/src/pre_lex.py ${PROJECT_SOURCE_DIR}/addon/doxywizard/${lex_file}.l
    DEPFILE ${GENERATED_SRC_WIZARD}/${lex_file}.d
    OUTPUT  ${GENERATED_SRC_WIZARD}/${lex_file}.l ${GENERATED_SRC_WIZARD}/${lex_file}.corr ${GENERATED_SRC_WIZARD}/${lex_file}.d
)

add_custom_command(
    COMMAND ${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/src/scan_states.py ${GENERATED_SRC_WIZARD}/${lex_file}.l > ${GENERATED_SRC_WIZARD}/${lex_file}.l.h
    DEPENDS ${PROJECT_SOURCE_DIR}/src/scan_states.py ${GENERATED_SRC_WIZARD}/${lex_file}.l
    OUTPUT  ${GENERATED_SRC_WIZARD}/${lex_file}.l.h
)

add_custom_command(OUTPUT ${PROJECT_BINARY_DIR}/doc/images/${f}
    COMMAND ${CMAKE_COMMAND} -E copy ${PROJECT_SOURCE_DIR}/addon/doxywizard/images/${f} ${PROJECT_BINARY_DIR}/doc/images/
    DEPENDS ${PROJECT_SOURCE_DIR}/addon/doxywizard/images/${f}
    )

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
)

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
)

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)

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
)

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
)

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
)

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

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

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

ADD_CUSTOM_COMMAND(
    OUTPUT hutidoc.pdf
    COMMAND "${PDFLATEX_COMPILER}" "${CMAKE_CURRENT_SOURCE_DIR}/hutidoc.tex"
    DEPENDS hutidoc.tex
)

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

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

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
)

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
)

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

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

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

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
)

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

add_custom_command(
  OUTPUT ${pcm}
  COMMAND ${CMAKE_CXX_COMPILER}
          -std=c++${std} -x c++-module --precompile -c
          -o ${pcm} ${CMAKE_CURRENT_SOURCE_DIR}/${src}
          "-I$<JOIN:$<TARGET_PROPERTY:${name},INCLUDE_DIRECTORIES>,;-I>"
  # Required by the -I generator expression above.
  COMMAND_EXPAND_LISTS
  DEPENDS ${src})

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

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

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

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
)

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
)

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
)

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
)

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
)

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

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

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

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

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

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
)

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

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

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

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

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

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)

add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_GraphvizView-internal.cpp
    COMMAND ${QtCore_MOC_EXECUTABLE} -o ${CMAKE_CURRENT_BINARY_DIR}/moc_GraphvizView-internal.cpp ${CMAKE_CURRENT_SOURCE_DIR}/GraphvizView.cpp
    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/GraphvizView.cpp)

add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_GraphvizView.cpp
    COMMAND ${QtCore_MOC_EXECUTABLE} -o ${CMAKE_CURRENT_BINARY_DIR}/moc_GraphvizView.cpp ${CMAKE_CURRENT_SOURCE_DIR}/GraphvizView.h
    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/GraphvizView.h)

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
)

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