| #[=======================================================================[.rst: |
| ExternalProject |
| --------------- |
| |
| Create custom targets to build projects in external trees |
| |
| .. command:: ExternalProject_Add |
| |
| The ``ExternalProject_Add`` function creates a custom target to drive |
| download, update/patch, configure, build, install and test steps of an |
| external project:: |
| |
| ExternalProject_Add(<name> [<option>...]) |
| |
| General options are: |
| |
| ``DEPENDS <projects>...`` |
| Targets on which the project depends |
| ``PREFIX <dir>`` |
| Root dir for entire project |
| ``LIST_SEPARATOR <sep>`` |
| Sep to be replaced by ; in cmd lines |
| ``TMP_DIR <dir>`` |
| Directory to store temporary files |
| ``STAMP_DIR <dir>`` |
| Directory to store step timestamps |
| ``EXCLUDE_FROM_ALL 1`` |
| The "all" target does not depend on this |
| |
| Download step options are: |
| |
| ``DOWNLOAD_NAME <fname>`` |
| File name to store (if not end of URL) |
| ``DOWNLOAD_DIR <dir>`` |
| Directory to store downloaded files |
| ``DOWNLOAD_COMMAND <cmd>...`` |
| Command to download source tree |
| ``DOWNLOAD_NO_PROGRESS 1`` |
| Disable download progress reports |
| ``CVS_REPOSITORY <cvsroot>`` |
| CVSROOT of CVS repository |
| ``CVS_MODULE <mod>`` |
| Module to checkout from CVS repo |
| ``CVS_TAG <tag>`` |
| Tag to checkout from CVS repo |
| ``SVN_REPOSITORY <url>`` |
| URL of Subversion repo |
| ``SVN_REVISION -r<rev>`` |
| Revision to checkout from Subversion repo |
| ``SVN_USERNAME <username>`` |
| Username for Subversion checkout and update |
| ``SVN_PASSWORD <password>`` |
| Password for Subversion checkout and update |
| ``SVN_TRUST_CERT 1`` |
| Trust the Subversion server site certificate |
| ``GIT_REPOSITORY <url>`` |
| URL of git repo |
| ``GIT_TAG <tag>`` |
| Git branch name, commit id or tag |
| ``GIT_SUBMODULES <module>...`` |
| Git submodules that shall be updated, all if empty |
| ``HG_REPOSITORY <url>`` |
| URL of mercurial repo |
| ``HG_TAG <tag>`` |
| Mercurial branch name, commit id or tag |
| ``URL /.../src.tgz`` |
| Full path or URL of source |
| ``URL_HASH ALGO=value`` |
| Hash of file at URL |
| ``URL_MD5 md5`` |
| Equivalent to URL_HASH MD5=md5 |
| ``TLS_VERIFY <bool>`` |
| Should certificate for https be checked |
| ``TLS_CAINFO <file>`` |
| Path to a certificate authority file |
| ``TIMEOUT <seconds>`` |
| Time allowed for file download operations |
| |
| Update/Patch step options are: |
| |
| ``UPDATE_COMMAND <cmd>...`` |
| Source work-tree update command |
| ``UPDATE_DISCONNECTED 1`` |
| Never update automatically from the remote repository |
| ``PATCH_COMMAND <cmd>...`` |
| Command to patch downloaded source |
| |
| Configure step options are: |
| |
| ``SOURCE_DIR <dir>`` |
| Source dir to be used for build |
| ``CONFIGURE_COMMAND <cmd>...`` |
| Build tree configuration command |
| ``CMAKE_COMMAND /.../cmake`` |
| Specify alternative cmake executable |
| ``CMAKE_GENERATOR <gen>`` |
| Specify generator for native build |
| ``CMAKE_GENERATOR_PLATFORM <platform>`` |
| Generator-specific platform name |
| ``CMAKE_GENERATOR_TOOLSET <toolset>`` |
| Generator-specific toolset name |
| ``CMAKE_ARGS <arg>...`` |
| Arguments to CMake command line. |
| These arguments are passed to CMake command line, and can contain |
| arguments other than cache values, see also |
| :manual:`CMake Options <cmake(1)>`. Arguments in the form |
| ``-Dvar:string=on`` are always passed to the command line, and |
| therefore cannot be changed by the user. |
| ``CMAKE_CACHE_ARGS <arg>...`` |
| Initial cache arguments, of the form ``-Dvar:string=on``. |
| These arguments are written in a pre-load a script that populates |
| CMake cache, see also :manual:`cmake -C <cmake(1)>`. This allows to |
| overcome command line length limits. |
| These arguments are :command:`set` using the ``FORCE`` argument, |
| and therefore cannot be changed by the user. |
| ``CMAKE_CACHE_DEFAULT_ARGS <arg>...`` |
| Initial default cache arguments, of the form ``-Dvar:string=on``. |
| These arguments are written in a pre-load a script that populates |
| CMake cache, see also :manual:`cmake -C <cmake(1)>`. This allows to |
| overcome command line length limits. |
| These arguments can be used as default value that will be set if no |
| previous value is found in the cache, and that the user can change |
| later. |
| |
| Build step options are: |
| |
| ``BINARY_DIR <dir>`` |
| Specify build dir location |
| ``BUILD_COMMAND <cmd>...`` |
| Command to drive the native build |
| ``BUILD_IN_SOURCE 1`` |
| Use source dir for build dir |
| ``BUILD_ALWAYS 1`` |
| No stamp file, build step always runs |
| ``BUILD_BYPRODUCTS <file>...`` |
| Files that will be generated by the build command but may or may |
| not have their modification time updated by subsequent builds. |
| |
| Install step options are: |
| |
| ``INSTALL_DIR <dir>`` |
| Installation prefix |
| ``INSTALL_COMMAND <cmd>...`` |
| Command to drive install after build |
| |
| Test step options are: |
| |
| ``TEST_BEFORE_INSTALL 1`` |
| Add test step executed before install step |
| ``TEST_AFTER_INSTALL 1`` |
| Add test step executed after install step |
| ``TEST_EXCLUDE_FROM_MAIN 1`` |
| Main target does not depend on the test step |
| ``TEST_COMMAND <cmd>...`` |
| Command to drive test |
| |
| Output logging options are: |
| |
| ``LOG_DOWNLOAD 1`` |
| Wrap download in script to log output |
| ``LOG_UPDATE 1`` |
| Wrap update in script to log output |
| ``LOG_CONFIGURE 1`` |
| Wrap configure in script to log output |
| ``LOG_BUILD 1`` |
| Wrap build in script to log output |
| ``LOG_TEST 1`` |
| Wrap test in script to log output |
| ``LOG_INSTALL 1`` |
| Wrap install in script to log output |
| |
| Other options are: |
| |
| ``STEP_TARGETS <step-target>...`` |
| Generate custom targets for these steps |
| ``INDEPENDENT_STEP_TARGETS <step-target>...`` |
| Generate custom targets for these steps that do not depend on other |
| external projects even if a dependency is set |
| |
| The ``*_DIR`` options specify directories for the project, with default |
| directories computed as follows. If the ``PREFIX`` option is given to |
| ``ExternalProject_Add()`` or the ``EP_PREFIX`` directory property is set, |
| then an external project is built and installed under the specified prefix:: |
| |
| TMP_DIR = <prefix>/tmp |
| STAMP_DIR = <prefix>/src/<name>-stamp |
| DOWNLOAD_DIR = <prefix>/src |
| SOURCE_DIR = <prefix>/src/<name> |
| BINARY_DIR = <prefix>/src/<name>-build |
| INSTALL_DIR = <prefix> |
| |
| Otherwise, if the ``EP_BASE`` directory property is set then components |
| of an external project are stored under the specified base:: |
| |
| TMP_DIR = <base>/tmp/<name> |
| STAMP_DIR = <base>/Stamp/<name> |
| DOWNLOAD_DIR = <base>/Download/<name> |
| SOURCE_DIR = <base>/Source/<name> |
| BINARY_DIR = <base>/Build/<name> |
| INSTALL_DIR = <base>/Install/<name> |
| |
| If no ``PREFIX``, ``EP_PREFIX``, or ``EP_BASE`` is specified then the |
| default is to set ``PREFIX`` to ``<name>-prefix``. Relative paths are |
| interpreted with respect to the build directory corresponding to the |
| source directory in which ``ExternalProject_Add`` is invoked. |
| |
| If ``SOURCE_DIR`` is explicitly set to an existing directory the project |
| will be built from it. Otherwise a download step must be specified |
| using one of the ``DOWNLOAD_COMMAND``, ``CVS_*``, ``SVN_*``, or ``URL`` |
| options. The ``URL`` option may refer locally to a directory or source |
| tarball, or refer to a remote tarball (e.g. ``http://.../src.tgz``). |
| |
| If ``UPDATE_DISCONNECTED`` is set, the update step is not executed |
| automatically when building the main target. The update step can still |
| be added as a step target and called manually. This is useful if you |
| want to allow to build the project when you are disconnected from the |
| network (you might still need the network for the download step). |
| This is disabled by default. |
| The directory property ``EP_UPDATE_DISCONNECTED`` can be used to change |
| the default value for all the external projects in the current |
| directory and its subdirectories. |
| |
| .. command:: ExternalProject_Add_Step |
| |
| The ``ExternalProject_Add_Step`` function adds a custom step to an |
| external project:: |
| |
| ExternalProject_Add_Step(<name> <step> [<option>...]) |
| |
| Options are: |
| |
| ``COMMAND <cmd>...`` |
| Command line invoked by this step |
| ``COMMENT "<text>..."`` |
| Text printed when step executes |
| ``DEPENDEES <step>...`` |
| Steps on which this step depends |
| ``DEPENDERS <step>...`` |
| Steps that depend on this step |
| ``DEPENDS <file>...`` |
| Files on which this step depends |
| ``BYPRODUCTS <file>...`` |
| Files that will be generated by this step but may or may not |
| have their modification time updated by subsequent builds. |
| ``ALWAYS 1`` |
| No stamp file, step always runs |
| ``EXCLUDE_FROM_MAIN 1`` |
| Main target does not depend on this step |
| ``WORKING_DIRECTORY <dir>`` |
| Working directory for command |
| ``LOG 1`` |
| Wrap step in script to log output |
| |
| The command line, comment, and working directory of every standard and |
| custom step is processed to replace tokens ``<SOURCE_DIR>``, |
| ``<BINARY_DIR>``, ``<INSTALL_DIR>``, and ``<TMP_DIR>`` with |
| corresponding property values. |
| |
| Any builtin step that specifies a ``<step>_COMMAND cmd...`` or custom |
| step that specifies a ``COMMAND cmd...`` may specify additional command |
| lines using the form ``COMMAND cmd...``. At build time the commands |
| will be executed in order and aborted if any one fails. For example:: |
| |
| ... BUILD_COMMAND make COMMAND echo done ... |
| |
| specifies to run ``make`` and then ``echo done`` during the build step. |
| Whether the current working directory is preserved between commands is |
| not defined. Behavior of shell operators like ``&&`` is not defined. |
| |
| .. command:: ExternalProject_Get_Property |
| |
| The ``ExternalProject_Get_Property`` function retrieves external project |
| target properties:: |
| |
| ExternalProject_Get_Property(<name> [prop1 [prop2 [...]]]) |
| |
| It stores property values in variables of the same name. Property |
| names correspond to the keyword argument names of |
| ``ExternalProject_Add``. |
| |
| .. command:: ExternalProject_Add_StepTargets |
| |
| The ``ExternalProject_Add_StepTargets`` function generates custom |
| targets for the steps listed:: |
| |
| ExternalProject_Add_StepTargets(<name> [NO_DEPENDS] [step1 [step2 [...]]]) |
| |
| If ``NO_DEPENDS`` is set, the target will not depend on the |
| dependencies of the complete project. This is usually safe to use for |
| the download, update, and patch steps that do not require that all the |
| dependencies are updated and built. Using ``NO_DEPENDS`` for other |
| of the default steps might break parallel builds, so you should avoid, |
| it. For custom steps, you should consider whether or not the custom |
| commands requires that the dependencies are configured, built and |
| installed. |
| |
| If ``STEP_TARGETS`` or ``INDEPENDENT_STEP_TARGETS`` is set then |
| ``ExternalProject_Add_StepTargets`` is automatically called at the end |
| of matching calls to ``ExternalProject_Add_Step``. Pass |
| ``STEP_TARGETS`` or ``INDEPENDENT_STEP_TARGETS`` explicitly to |
| individual ``ExternalProject_Add`` calls, or implicitly to all |
| ``ExternalProject_Add`` calls by setting the directory properties |
| ``EP_STEP_TARGETS`` and ``EP_INDEPENDENT_STEP_TARGETS``. The |
| ``INDEPENDENT`` version of the argument and of the property will call |
| ``ExternalProject_Add_StepTargets`` with the ``NO_DEPENDS`` argument. |
| |
| If ``STEP_TARGETS`` and ``INDEPENDENT_STEP_TARGETS`` are not set, |
| clients may still manually call ``ExternalProject_Add_StepTargets`` |
| after calling ``ExternalProject_Add`` or ``ExternalProject_Add_Step``. |
| |
| This functionality is provided to make it easy to drive the steps |
| independently of each other by specifying targets on build command |
| lines. For example, you may be submitting to a sub-project based |
| dashboard, where you want to drive the configure portion of the build, |
| then submit to the dashboard, followed by the build portion, followed |
| by tests. If you invoke a custom target that depends on a step |
| halfway through the step dependency chain, then all the previous steps |
| will also run to ensure everything is up to date. |
| |
| For example, to drive configure, build and test steps independently |
| for each ``ExternalProject_Add`` call in your project, write the following |
| line prior to any ``ExternalProject_Add`` calls in your ``CMakeLists.txt`` |
| file:: |
| |
| set_property(DIRECTORY PROPERTY EP_STEP_TARGETS configure build test) |
| |
| .. command:: ExternalProject_Add_StepDependencies |
| |
| The ``ExternalProject_Add_StepDependencies`` function add some |
| dependencies for some external project step:: |
| |
| ExternalProject_Add_StepDependencies(<name> <step> [target1 [target2 [...]]]) |
| |
| This function takes care to set both target and file level |
| dependencies, and will ensure that parallel builds will not break. |
| It should be used instead of :command:`add_dependencies()` when adding |
| a dependency for some of the step targets generated by |
| ``ExternalProject``. |
| #]=======================================================================] |
| |
| #============================================================================= |
| # Copyright 2008-2013 Kitware, Inc. |
| # |
| # Distributed under the OSI-approved BSD License (the "License"); |
| # see accompanying file Copyright.txt for details. |
| # |
| # This software is distributed WITHOUT ANY WARRANTY; without even the |
| # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| # See the License for more information. |
| #============================================================================= |
| # (To distribute this file outside of CMake, substitute the full |
| # License text for the above reference.) |
| |
| # Pre-compute a regex to match documented keywords for each command. |
| math(EXPR _ep_documentation_line_count "${CMAKE_CURRENT_LIST_LINE} - 16") |
| file(STRINGS "${CMAKE_CURRENT_LIST_FILE}" lines |
| LIMIT_COUNT ${_ep_documentation_line_count} |
| REGEX "^\\.\\. command:: [A-Za-z0-9_]+|^ ``[A-Z0-9_]+ .*``$") |
| foreach(line IN LISTS lines) |
| if("${line}" MATCHES "^\\.\\. command:: ([A-Za-z0-9_]+)") |
| if(_ep_func) |
| set(_ep_keywords_${_ep_func} "${_ep_keywords_${_ep_func}})$") |
| endif() |
| set(_ep_func "${CMAKE_MATCH_1}") |
| #message("function [${_ep_func}]") |
| set(_ep_keywords_${_ep_func} "^(") |
| set(_ep_keyword_sep) |
| elseif("${line}" MATCHES "^ ``([A-Z0-9_]+) .*``$") |
| set(_ep_key "${CMAKE_MATCH_1}") |
| #message(" keyword [${_ep_key}]") |
| set(_ep_keywords_${_ep_func} |
| "${_ep_keywords_${_ep_func}}${_ep_keyword_sep}${_ep_key}") |
| set(_ep_keyword_sep "|") |
| endif() |
| endforeach() |
| if(_ep_func) |
| set(_ep_keywords_${_ep_func} "${_ep_keywords_${_ep_func}})$") |
| endif() |
| |
| # Save regex matching supported hash algorithm names. |
| set(_ep_hash_algos "MD5|SHA1|SHA224|SHA256|SHA384|SHA512") |
| set(_ep_hash_regex "^(${_ep_hash_algos})=([0-9A-Fa-f]+)$") |
| |
| function(_ep_parse_arguments f name ns args) |
| # Transfer the arguments to this function into target properties for the |
| # new custom target we just added so that we can set up all the build steps |
| # correctly based on target properties. |
| # |
| # We loop through ARGN and consider the namespace starting with an |
| # upper-case letter followed by at least two more upper-case letters, |
| # numbers or underscores to be keywords. |
| set(key) |
| |
| foreach(arg IN LISTS args) |
| set(is_value 1) |
| |
| if(arg MATCHES "^[A-Z][A-Z0-9_][A-Z0-9_]+$" AND |
| NOT (("x${arg}x" STREQUAL "x${key}x") AND ("x${key}x" STREQUAL "xCOMMANDx")) AND |
| NOT arg MATCHES "^(TRUE|FALSE)$") |
| if(_ep_keywords_${f} AND arg MATCHES "${_ep_keywords_${f}}") |
| set(is_value 0) |
| endif() |
| endif() |
| |
| if(is_value) |
| if(key) |
| # Value |
| if(NOT arg STREQUAL "") |
| set_property(TARGET ${name} APPEND PROPERTY ${ns}${key} "${arg}") |
| else() |
| get_property(have_key TARGET ${name} PROPERTY ${ns}${key} SET) |
| if(have_key) |
| get_property(value TARGET ${name} PROPERTY ${ns}${key}) |
| set_property(TARGET ${name} PROPERTY ${ns}${key} "${value};${arg}") |
| else() |
| set_property(TARGET ${name} PROPERTY ${ns}${key} "${arg}") |
| endif() |
| endif() |
| else() |
| # Missing Keyword |
| message(AUTHOR_WARNING "value '${arg}' with no previous keyword in ${f}") |
| endif() |
| else() |
| set(key "${arg}") |
| endif() |
| endforeach() |
| endfunction() |
| |
| |
| define_property(DIRECTORY PROPERTY "EP_BASE" INHERITED |
| BRIEF_DOCS "Base directory for External Project storage." |
| FULL_DOCS |
| "See documentation of the ExternalProject_Add() function in the " |
| "ExternalProject module." |
| ) |
| |
| define_property(DIRECTORY PROPERTY "EP_PREFIX" INHERITED |
| BRIEF_DOCS "Top prefix for External Project storage." |
| FULL_DOCS |
| "See documentation of the ExternalProject_Add() function in the " |
| "ExternalProject module." |
| ) |
| |
| define_property(DIRECTORY PROPERTY "EP_STEP_TARGETS" INHERITED |
| BRIEF_DOCS |
| "List of ExternalProject steps that automatically get corresponding targets" |
| FULL_DOCS |
| "These targets will be dependent on the main target dependencies" |
| "See documentation of the ExternalProject_Add_StepTargets() function in the " |
| "ExternalProject module." |
| ) |
| |
| define_property(DIRECTORY PROPERTY "EP_INDEPENDENT_STEP_TARGETS" INHERITED |
| BRIEF_DOCS |
| "List of ExternalProject steps that automatically get corresponding targets" |
| FULL_DOCS |
| "These targets will not be dependent on the main target dependencies" |
| "See documentation of the ExternalProject_Add_StepTargets() function in the " |
| "ExternalProject module." |
| ) |
| |
| define_property(DIRECTORY PROPERTY "EP_UPDATE_DISCONNECTED" INHERITED |
| BRIEF_DOCS "Never update automatically from the remote repo." |
| FULL_DOCS |
| "See documentation of the ExternalProject_Add() function in the " |
| "ExternalProject module." |
| ) |
| |
| function(_ep_write_gitclone_script script_filename source_dir git_EXECUTABLE git_repository git_tag git_submodules src_name work_dir gitclone_infofile gitclone_stampfile) |
| file(WRITE ${script_filename} |
| "if(\"${git_tag}\" STREQUAL \"\") |
| message(FATAL_ERROR \"Tag for git checkout should not be empty.\") |
| endif() |
| |
| set(run 0) |
| |
| if(\"${gitclone_infofile}\" IS_NEWER_THAN \"${gitclone_stampfile}\") |
| set(run 1) |
| endif() |
| |
| if(NOT run) |
| message(STATUS \"Avoiding repeated git clone, stamp file is up to date: '${gitclone_stampfile}'\") |
| return() |
| endif() |
| |
| execute_process( |
| COMMAND \${CMAKE_COMMAND} -E remove_directory \"${source_dir}\" |
| RESULT_VARIABLE error_code |
| ) |
| if(error_code) |
| message(FATAL_ERROR \"Failed to remove directory: '${source_dir}'\") |
| endif() |
| |
| # try the clone 3 times incase there is an odd git clone issue |
| set(error_code 1) |
| set(number_of_tries 0) |
| while(error_code AND number_of_tries LESS 3) |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" clone \"${git_repository}\" \"${src_name}\" |
| WORKING_DIRECTORY \"${work_dir}\" |
| RESULT_VARIABLE error_code |
| ) |
| math(EXPR number_of_tries \"\${number_of_tries} + 1\") |
| endwhile() |
| if(number_of_tries GREATER 1) |
| message(STATUS \"Had to git clone more than once: |
| \${number_of_tries} times.\") |
| endif() |
| if(error_code) |
| message(FATAL_ERROR \"Failed to clone repository: '${git_repository}'\") |
| endif() |
| |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" checkout ${git_tag} |
| WORKING_DIRECTORY \"${work_dir}/${src_name}\" |
| RESULT_VARIABLE error_code |
| ) |
| if(error_code) |
| message(FATAL_ERROR \"Failed to checkout tag: '${git_tag}'\") |
| endif() |
| |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" submodule init |
| WORKING_DIRECTORY \"${work_dir}/${src_name}\" |
| RESULT_VARIABLE error_code |
| ) |
| if(error_code) |
| message(FATAL_ERROR \"Failed to init submodules in: '${work_dir}/${src_name}'\") |
| endif() |
| |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" submodule update --recursive ${git_submodules} |
| WORKING_DIRECTORY \"${work_dir}/${src_name}\" |
| RESULT_VARIABLE error_code |
| ) |
| if(error_code) |
| message(FATAL_ERROR \"Failed to update submodules in: '${work_dir}/${src_name}'\") |
| endif() |
| |
| # Complete success, update the script-last-run stamp file: |
| # |
| execute_process( |
| COMMAND \${CMAKE_COMMAND} -E copy |
| \"${gitclone_infofile}\" |
| \"${gitclone_stampfile}\" |
| WORKING_DIRECTORY \"${work_dir}/${src_name}\" |
| RESULT_VARIABLE error_code |
| ) |
| if(error_code) |
| message(FATAL_ERROR \"Failed to copy script-last-run stamp file: '${gitclone_stampfile}'\") |
| endif() |
| |
| " |
| ) |
| |
| endfunction() |
| |
| function(_ep_write_hgclone_script script_filename source_dir hg_EXECUTABLE hg_repository hg_tag src_name work_dir hgclone_infofile hgclone_stampfile) |
| file(WRITE ${script_filename} |
| "if(\"${hg_tag}\" STREQUAL \"\") |
| message(FATAL_ERROR \"Tag for hg checkout should not be empty.\") |
| endif() |
| |
| set(run 0) |
| |
| if(\"${hgclone_infofile}\" IS_NEWER_THAN \"${hgclone_stampfile}\") |
| set(run 1) |
| endif() |
| |
| if(NOT run) |
| message(STATUS \"Avoiding repeated hg clone, stamp file is up to date: '${hgclone_stampfile}'\") |
| return() |
| endif() |
| |
| execute_process( |
| COMMAND \${CMAKE_COMMAND} -E remove_directory \"${source_dir}\" |
| RESULT_VARIABLE error_code |
| ) |
| if(error_code) |
| message(FATAL_ERROR \"Failed to remove directory: '${source_dir}'\") |
| endif() |
| |
| execute_process( |
| COMMAND \"${hg_EXECUTABLE}\" clone \"${hg_repository}\" \"${src_name}\" |
| WORKING_DIRECTORY \"${work_dir}\" |
| RESULT_VARIABLE error_code |
| ) |
| if(error_code) |
| message(FATAL_ERROR \"Failed to clone repository: '${hg_repository}'\") |
| endif() |
| |
| execute_process( |
| COMMAND \"${hg_EXECUTABLE}\" update ${hg_tag} |
| WORKING_DIRECTORY \"${work_dir}/${src_name}\" |
| RESULT_VARIABLE error_code |
| ) |
| if(error_code) |
| message(FATAL_ERROR \"Failed to checkout tag: '${hg_tag}'\") |
| endif() |
| |
| # Complete success, update the script-last-run stamp file: |
| # |
| execute_process( |
| COMMAND \${CMAKE_COMMAND} -E copy |
| \"${hgclone_infofile}\" |
| \"${hgclone_stampfile}\" |
| WORKING_DIRECTORY \"${work_dir}/${src_name}\" |
| RESULT_VARIABLE error_code |
| ) |
| if(error_code) |
| message(FATAL_ERROR \"Failed to copy script-last-run stamp file: '${hgclone_stampfile}'\") |
| endif() |
| |
| " |
| ) |
| |
| endfunction() |
| |
| |
| function(_ep_write_gitupdate_script script_filename git_EXECUTABLE git_tag git_submodules git_repository work_dir) |
| file(WRITE ${script_filename} |
| "if(\"${git_tag}\" STREQUAL \"\") |
| message(FATAL_ERROR \"Tag for git checkout should not be empty.\") |
| endif() |
| |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" rev-list --max-count=1 HEAD |
| WORKING_DIRECTORY \"${work_dir}\" |
| RESULT_VARIABLE error_code |
| OUTPUT_VARIABLE head_sha |
| OUTPUT_STRIP_TRAILING_WHITESPACE |
| ) |
| if(error_code) |
| message(FATAL_ERROR \"Failed to get the hash for HEAD\") |
| endif() |
| |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" show-ref ${git_tag} |
| WORKING_DIRECTORY \"${work_dir}\" |
| OUTPUT_VARIABLE show_ref_output |
| ) |
| # If a remote ref is asked for, which can possibly move around, |
| # we must always do a fetch and checkout. |
| if(\"\${show_ref_output}\" MATCHES \"remotes\") |
| set(is_remote_ref 1) |
| else() |
| set(is_remote_ref 0) |
| endif() |
| |
| # Tag is in the form <remote>/<tag> (i.e. origin/master) we must strip |
| # the remote from the tag. |
| if(\"\${show_ref_output}\" MATCHES \"refs/remotes/${git_tag}\") |
| string(REGEX MATCH \"^([^/]+)/(.+)$\" _unused \"${git_tag}\") |
| set(git_remote \"\${CMAKE_MATCH_1}\") |
| set(git_tag \"\${CMAKE_MATCH_2}\") |
| else() |
| set(git_remote \"origin\") |
| set(git_tag \"${git_tag}\") |
| endif() |
| |
| # This will fail if the tag does not exist (it probably has not been fetched |
| # yet). |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" rev-list --max-count=1 ${git_tag} |
| WORKING_DIRECTORY \"${work_dir}\" |
| RESULT_VARIABLE error_code |
| OUTPUT_VARIABLE tag_sha |
| OUTPUT_STRIP_TRAILING_WHITESPACE |
| ) |
| |
| # Is the hash checkout out that we want? |
| if(error_code OR is_remote_ref OR NOT (\"\${tag_sha}\" STREQUAL \"\${head_sha}\")) |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" fetch |
| WORKING_DIRECTORY \"${work_dir}\" |
| RESULT_VARIABLE error_code |
| ) |
| if(error_code) |
| message(FATAL_ERROR \"Failed to fetch repository '${git_repository}'\") |
| endif() |
| |
| if(is_remote_ref) |
| # Check if stash is needed |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" status --porcelain |
| WORKING_DIRECTORY \"${work_dir}\" |
| RESULT_VARIABLE error_code |
| OUTPUT_VARIABLE repo_status |
| ) |
| if(error_code) |
| message(FATAL_ERROR \"Failed to get the status\") |
| endif() |
| string(LENGTH \"\${repo_status}\" need_stash) |
| |
| # If not in clean state, stash changes in order to be able to be able to |
| # perform git pull --rebase |
| if(need_stash) |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" stash save --all --quiet |
| WORKING_DIRECTORY \"${work_dir}\" |
| RESULT_VARIABLE error_code |
| ) |
| if(error_code) |
| message(FATAL_ERROR \"Failed to stash changes\") |
| endif() |
| endif() |
| |
| # Pull changes from the remote branch |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" rebase \${git_remote}/\${git_tag} |
| WORKING_DIRECTORY \"${work_dir}\" |
| RESULT_VARIABLE error_code |
| ) |
| if(error_code) |
| # Rebase failed: Restore previous state. |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" rebase --abort |
| WORKING_DIRECTORY \"${work_dir}\" |
| ) |
| if(need_stash) |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" stash pop --index --quiet |
| WORKING_DIRECTORY \"${work_dir}\" |
| ) |
| endif() |
| message(FATAL_ERROR \"\\nFailed to rebase in: '${work_dir}/${src_name}'.\\nYou will have to resolve the conflicts manually\") |
| endif() |
| |
| if(need_stash) |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" stash pop --index --quiet |
| WORKING_DIRECTORY \"${work_dir}\" |
| RESULT_VARIABLE error_code |
| ) |
| if(error_code) |
| # Stash pop --index failed: Try again dropping the index |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" reset --hard --quiet |
| WORKING_DIRECTORY \"${work_dir}\" |
| RESULT_VARIABLE error_code |
| ) |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" stash pop --quiet |
| WORKING_DIRECTORY \"${work_dir}\" |
| RESULT_VARIABLE error_code |
| ) |
| if(error_code) |
| # Stash pop failed: Restore previous state. |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" reset --hard --quiet \${head_sha} |
| WORKING_DIRECTORY \"${work_dir}\" |
| ) |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" stash pop --index --quiet |
| WORKING_DIRECTORY \"${work_dir}\" |
| ) |
| message(FATAL_ERROR \"\\nFailed to unstash changes in: '${work_dir}/${src_name}'.\\nYou will have to resolve the conflicts manually\") |
| endif() |
| endif() |
| endif() |
| else() |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" checkout ${git_tag} |
| WORKING_DIRECTORY \"${work_dir}\" |
| RESULT_VARIABLE error_code |
| ) |
| if(error_code) |
| message(FATAL_ERROR \"Failed to checkout tag: '${git_tag}'\") |
| endif() |
| endif() |
| |
| execute_process( |
| COMMAND \"${git_EXECUTABLE}\" submodule update --recursive ${git_submodules} |
| WORKING_DIRECTORY \"${work_dir}/${src_name}\" |
| RESULT_VARIABLE error_code |
| ) |
| if(error_code) |
| message(FATAL_ERROR \"Failed to update submodules in: '${work_dir}/${src_name}'\") |
| endif() |
| endif() |
| |
| " |
| ) |
| |
| endfunction(_ep_write_gitupdate_script) |
| |
| function(_ep_write_downloadfile_script script_filename remote local timeout no_progress hash tls_verify tls_cainfo) |
| if(timeout) |
| set(timeout_args TIMEOUT ${timeout}) |
| set(timeout_msg "${timeout} seconds") |
| else() |
| set(timeout_args "# no TIMEOUT") |
| set(timeout_msg "none") |
| endif() |
| |
| if(no_progress) |
| set(show_progress "") |
| else() |
| set(show_progress "SHOW_PROGRESS") |
| endif() |
| |
| if("${hash}" MATCHES "${_ep_hash_regex}") |
| string(CONCAT hash_check |
| "if(EXISTS \"${local}\")\n" |
| " file(\"${CMAKE_MATCH_1}\" \"${local}\" hash_value)\n" |
| " if(\"x\${hash_value}\" STREQUAL \"x${CMAKE_MATCH_2}\")\n" |
| " return()\n" |
| " endif()\n" |
| "endif()\n" |
| ) |
| else() |
| set(hash_check "") |
| endif() |
| |
| # check for curl globals in the project |
| if(DEFINED CMAKE_TLS_VERIFY) |
| set(tls_verify "set(CMAKE_TLS_VERIFY ${CMAKE_TLS_VERIFY})") |
| endif() |
| if(DEFINED CMAKE_TLS_CAINFO) |
| set(tls_cainfo "set(CMAKE_TLS_CAINFO \"${CMAKE_TLS_CAINFO}\")") |
| endif() |
| |
| # now check for curl locals so that the local values |
| # will override the globals |
| |
| # check for tls_verify argument |
| string(LENGTH "${tls_verify}" tls_verify_len) |
| if(tls_verify_len GREATER 0) |
| set(tls_verify "set(CMAKE_TLS_VERIFY ${tls_verify})") |
| endif() |
| # check for tls_cainfo argument |
| string(LENGTH "${tls_cainfo}" tls_cainfo_len) |
| if(tls_cainfo_len GREATER 0) |
| set(tls_cainfo "set(CMAKE_TLS_CAINFO \"${tls_cainfo}\")") |
| endif() |
| |
| file(WRITE ${script_filename} |
| "${hash_check}message(STATUS \"downloading... |
| src='${remote}' |
| dst='${local}' |
| timeout='${timeout_msg}'\") |
| |
| ${tls_verify} |
| ${tls_cainfo} |
| |
| file(DOWNLOAD |
| \"${remote}\" |
| \"${local}\" |
| ${show_progress} |
| ${timeout_args} |
| STATUS status |
| LOG log) |
| |
| list(GET status 0 status_code) |
| list(GET status 1 status_string) |
| |
| if(NOT status_code EQUAL 0) |
| message(FATAL_ERROR \"error: downloading '${remote}' failed |
| status_code: \${status_code} |
| status_string: \${status_string} |
| log: \${log} |
| \") |
| endif() |
| |
| message(STATUS \"downloading... done\") |
| " |
| ) |
| |
| endfunction() |
| |
| |
| function(_ep_write_verifyfile_script script_filename local hash retries download_script) |
| if("${hash}" MATCHES "${_ep_hash_regex}") |
| set(algo "${CMAKE_MATCH_1}") |
| string(TOLOWER "${CMAKE_MATCH_2}" expect_value) |
| set(script_content "set(expect_value \"${expect_value}\") |
| set(attempt 0) |
| set(succeeded 0) |
| while(\${attempt} LESS ${retries} OR \${attempt} EQUAL ${retries} AND NOT \${succeeded}) |
| file(${algo} \"\${file}\" actual_value) |
| if(\"\${actual_value}\" STREQUAL \"\${expect_value}\") |
| set(succeeded 1) |
| elseif(\${attempt} LESS ${retries}) |
| message(STATUS \"${algo} hash of \${file} |
| does not match expected value |
| expected: \${expect_value} |
| actual: \${actual_value} |
| Retrying download. |
| \") |
| file(REMOVE \"\${file}\") |
| execute_process(COMMAND \${CMAKE_COMMAND} -P \"${download_script}\") |
| endif() |
| math(EXPR attempt \"\${attempt} + 1\") |
| endwhile() |
| |
| if(\${succeeded}) |
| message(STATUS \"verifying file... done\") |
| else() |
| message(FATAL_ERROR \"error: ${algo} hash of |
| \${file} |
| does not match expected value |
| expected: \${expect_value} |
| actual: \${actual_value} |
| \") |
| endif()") |
| else() |
| set(script_content "message(STATUS \"verifying file... warning: did not verify file - no URL_HASH specified?\")") |
| endif() |
| file(WRITE ${script_filename} "set(file \"${local}\") |
| message(STATUS \"verifying file... |
| file='\${file}'\") |
| ${script_content} |
| ") |
| endfunction() |
| |
| |
| function(_ep_write_extractfile_script script_filename name filename directory) |
| set(args "") |
| |
| if(filename MATCHES "(\\.|=)(7z|tar\\.bz2|tar\\.gz|tar\\.xz|tbz2|tgz|txz|zip)$") |
| set(args xfz) |
| endif() |
| |
| if(filename MATCHES "(\\.|=)tar$") |
| set(args xf) |
| endif() |
| |
| if(args STREQUAL "") |
| message(SEND_ERROR "error: do not know how to extract '${filename}' -- known types are .7z, .tar, .tar.bz2, .tar.gz, .tar.xz, .tbz2, .tgz, .txz and .zip") |
| return() |
| endif() |
| |
| file(WRITE ${script_filename} |
| "# Make file names absolute: |
| # |
| get_filename_component(filename \"${filename}\" ABSOLUTE) |
| get_filename_component(directory \"${directory}\" ABSOLUTE) |
| |
| message(STATUS \"extracting... |
| src='\${filename}' |
| dst='\${directory}'\") |
| |
| if(NOT EXISTS \"\${filename}\") |
| message(FATAL_ERROR \"error: file to extract does not exist: '\${filename}'\") |
| endif() |
| |
| # Prepare a space for extracting: |
| # |
| set(i 1234) |
| while(EXISTS \"\${directory}/../ex-${name}\${i}\") |
| math(EXPR i \"\${i} + 1\") |
| endwhile() |
| set(ut_dir \"\${directory}/../ex-${name}\${i}\") |
| file(MAKE_DIRECTORY \"\${ut_dir}\") |
| |
| # Extract it: |
| # |
| message(STATUS \"extracting... [tar ${args}]\") |
| execute_process(COMMAND \${CMAKE_COMMAND} -E tar ${args} \${filename} |
| WORKING_DIRECTORY \${ut_dir} |
| RESULT_VARIABLE rv) |
| |
| if(NOT rv EQUAL 0) |
| message(STATUS \"extracting... [error clean up]\") |
| file(REMOVE_RECURSE \"\${ut_dir}\") |
| message(FATAL_ERROR \"error: extract of '\${filename}' failed\") |
| endif() |
| |
| # Analyze what came out of the tar file: |
| # |
| message(STATUS \"extracting... [analysis]\") |
| file(GLOB contents \"\${ut_dir}/*\") |
| list(LENGTH contents n) |
| if(NOT n EQUAL 1 OR NOT IS_DIRECTORY \"\${contents}\") |
| set(contents \"\${ut_dir}\") |
| endif() |
| |
| # Move \"the one\" directory to the final directory: |
| # |
| message(STATUS \"extracting... [rename]\") |
| file(REMOVE_RECURSE \${directory}) |
| get_filename_component(contents \${contents} ABSOLUTE) |
| file(RENAME \${contents} \${directory}) |
| |
| # Clean up: |
| # |
| message(STATUS \"extracting... [clean up]\") |
| file(REMOVE_RECURSE \"\${ut_dir}\") |
| |
| message(STATUS \"extracting... done\") |
| " |
| ) |
| |
| endfunction() |
| |
| |
| function(_ep_set_directories name) |
| get_property(prefix TARGET ${name} PROPERTY _EP_PREFIX) |
| if(NOT prefix) |
| get_property(prefix DIRECTORY PROPERTY EP_PREFIX) |
| if(NOT prefix) |
| get_property(base DIRECTORY PROPERTY EP_BASE) |
| if(NOT base) |
| set(prefix "${name}-prefix") |
| endif() |
| endif() |
| endif() |
| if(prefix) |
| set(tmp_default "${prefix}/tmp") |
| set(download_default "${prefix}/src") |
| set(source_default "${prefix}/src/${name}") |
| set(binary_default "${prefix}/src/${name}-build") |
| set(stamp_default "${prefix}/src/${name}-stamp") |
| set(install_default "${prefix}") |
| else() |
| set(tmp_default "${base}/tmp/${name}") |
| set(download_default "${base}/Download/${name}") |
| set(source_default "${base}/Source/${name}") |
| set(binary_default "${base}/Build/${name}") |
| set(stamp_default "${base}/Stamp/${name}") |
| set(install_default "${base}/Install/${name}") |
| endif() |
| get_property(build_in_source TARGET ${name} PROPERTY _EP_BUILD_IN_SOURCE) |
| if(build_in_source) |
| get_property(have_binary_dir TARGET ${name} PROPERTY _EP_BINARY_DIR SET) |
| if(have_binary_dir) |
| message(FATAL_ERROR |
| "External project ${name} has both BINARY_DIR and BUILD_IN_SOURCE!") |
| endif() |
| endif() |
| set(top "${CMAKE_CURRENT_BINARY_DIR}") |
| set(places stamp download source binary install tmp) |
| foreach(var ${places}) |
| string(TOUPPER "${var}" VAR) |
| get_property(${var}_dir TARGET ${name} PROPERTY _EP_${VAR}_DIR) |
| if(NOT ${var}_dir) |
| set(${var}_dir "${${var}_default}") |
| endif() |
| if(NOT IS_ABSOLUTE "${${var}_dir}") |
| get_filename_component(${var}_dir "${top}/${${var}_dir}" ABSOLUTE) |
| endif() |
| set_property(TARGET ${name} PROPERTY _EP_${VAR}_DIR "${${var}_dir}") |
| endforeach() |
| if(build_in_source) |
| get_property(source_dir TARGET ${name} PROPERTY _EP_SOURCE_DIR) |
| set_property(TARGET ${name} PROPERTY _EP_BINARY_DIR "${source_dir}") |
| endif() |
| |
| # Make the directories at CMake configure time *and* add a custom command |
| # to make them at build time. They need to exist at makefile generation |
| # time for Borland make and wmake so that CMake may generate makefiles |
| # with "cd C:\short\paths\with\no\spaces" commands in them. |
| # |
| # Additionally, the add_custom_command is still used in case somebody |
| # removes one of the necessary directories and tries to rebuild without |
| # re-running cmake. |
| foreach(var ${places}) |
| string(TOUPPER "${var}" VAR) |
| get_property(dir TARGET ${name} PROPERTY _EP_${VAR}_DIR) |
| file(MAKE_DIRECTORY "${dir}") |
| if(NOT EXISTS "${dir}") |
| message(FATAL_ERROR "dir '${dir}' does not exist after file(MAKE_DIRECTORY)") |
| endif() |
| endforeach() |
| endfunction() |
| |
| |
| # IMPORTANT: this MUST be a macro and not a function because of the |
| # in-place replacements that occur in each ${var} |
| # |
| macro(_ep_replace_location_tags target_name) |
| set(vars ${ARGN}) |
| foreach(var ${vars}) |
| if(${var}) |
| foreach(dir SOURCE_DIR BINARY_DIR INSTALL_DIR TMP_DIR) |
| get_property(val TARGET ${target_name} PROPERTY _EP_${dir}) |
| string(REPLACE "<${dir}>" "${val}" ${var} "${${var}}") |
| endforeach() |
| endif() |
| endforeach() |
| endmacro() |
| |
| |
| function(_ep_command_line_to_initial_cache var args force) |
| set(script_initial_cache "") |
| set(regex "^([^:]+):([^=]+)=(.*)$") |
| set(setArg "") |
| set(forceArg "") |
| if(force) |
| set(forceArg "FORCE") |
| endif() |
| foreach(line ${args}) |
| if("${line}" MATCHES "^-D(.*)") |
| set(line "${CMAKE_MATCH_1}") |
| if(setArg) |
| # This is required to build up lists in variables, or complete an entry |
| set(setArg "${setArg}${accumulator}\" CACHE ${type} \"Initial cache\" ${forceArg})") |
| set(script_initial_cache "${script_initial_cache}\n${setArg}") |
| set(accumulator "") |
| set(setArg "") |
| endif() |
| if("${line}" MATCHES "${regex}") |
| set(name "${CMAKE_MATCH_1}") |
| set(type "${CMAKE_MATCH_2}") |
| set(value "${CMAKE_MATCH_3}") |
| set(setArg "set(${name} \"${value}") |
| else() |
| message(WARNING "Line '${line}' does not match regex. Ignoring.") |
| endif() |
| else() |
| # Assume this is a list to append to the last var |
| set(accumulator "${accumulator};${line}") |
| endif() |
| endforeach() |
| # Catch the final line of the args |
| if(setArg) |
| set(setArg "${setArg}${accumulator}\" CACHE ${type} \"Initial cache\" ${forceArg})") |
| set(script_initial_cache "${script_initial_cache}\n${setArg}") |
| endif() |
| set(${var} ${script_initial_cache} PARENT_SCOPE) |
| endfunction() |
| |
| |
| function(_ep_write_initial_cache target_name script_filename script_initial_cache) |
| # Write out values into an initial cache, that will be passed to CMake with -C |
| # Replace location tags. |
| _ep_replace_location_tags(${target_name} script_initial_cache) |
| # Write out the initial cache file to the location specified. |
| if(NOT EXISTS "${script_filename}.in") |
| file(WRITE "${script_filename}.in" "\@script_initial_cache\@\n") |
| endif() |
| configure_file("${script_filename}.in" "${script_filename}") |
| endfunction() |
| |
| |
| function(ExternalProject_Get_Property name) |
| foreach(var ${ARGN}) |
| string(TOUPPER "${var}" VAR) |
| get_property(${var} TARGET ${name} PROPERTY _EP_${VAR}) |
| if(NOT ${var}) |
| message(FATAL_ERROR "External project \"${name}\" has no ${var}") |
| endif() |
| set(${var} "${${var}}" PARENT_SCOPE) |
| endforeach() |
| endfunction() |
| |
| |
| function(_ep_get_configure_command_id name cfg_cmd_id_var) |
| get_target_property(cmd ${name} _EP_CONFIGURE_COMMAND) |
| |
| if(cmd STREQUAL "") |
| # Explicit empty string means no configure step for this project |
| set(${cfg_cmd_id_var} "none" PARENT_SCOPE) |
| else() |
| if(NOT cmd) |
| # Default is "use cmake": |
| set(${cfg_cmd_id_var} "cmake" PARENT_SCOPE) |
| else() |
| # Otherwise we have to analyze the value: |
| if(cmd MATCHES "^[^;]*/configure") |
| set(${cfg_cmd_id_var} "configure" PARENT_SCOPE) |
| elseif(cmd MATCHES "^[^;]*/cmake" AND NOT cmd MATCHES ";-[PE];") |
| set(${cfg_cmd_id_var} "cmake" PARENT_SCOPE) |
| elseif(cmd MATCHES "config") |
| set(${cfg_cmd_id_var} "configure" PARENT_SCOPE) |
| else() |
| set(${cfg_cmd_id_var} "unknown:${cmd}" PARENT_SCOPE) |
| endif() |
| endif() |
| endif() |
| endfunction() |
| |
| |
| function(_ep_get_build_command name step cmd_var) |
| set(cmd "${${cmd_var}}") |
| if(NOT cmd) |
| set(args) |
| _ep_get_configure_command_id(${name} cfg_cmd_id) |
| if(cfg_cmd_id STREQUAL "cmake") |
| # CMake project. Select build command based on generator. |
| get_target_property(cmake_generator ${name} _EP_CMAKE_GENERATOR) |
| if("${CMAKE_GENERATOR}" MATCHES "Make" AND |
| ("${cmake_generator}" MATCHES "Make" OR NOT cmake_generator)) |
| # The project uses the same Makefile generator. Use recursive make. |
| set(cmd "$(MAKE)") |
| if(step STREQUAL "INSTALL") |
| set(args install) |
| endif() |
| if(step STREQUAL "TEST") |
| set(args test) |
| endif() |
| else() |
| # Drive the project with "cmake --build". |
| get_target_property(cmake_command ${name} _EP_CMAKE_COMMAND) |
| if(cmake_command) |
| set(cmd "${cmake_command}") |
| else() |
| set(cmd "${CMAKE_COMMAND}") |
| endif() |
| set(args --build ${binary_dir} --config ${CMAKE_CFG_INTDIR}) |
| if(step STREQUAL "INSTALL") |
| list(APPEND args --target install) |
| endif() |
| # But for "TEST" drive the project with corresponding "ctest". |
| if(step STREQUAL "TEST") |
| string(REGEX REPLACE "^(.*/)cmake([^/]*)$" "\\1ctest\\2" cmd "${cmd}") |
| set(args "") |
| endif() |
| endif() |
| else() |
| # Non-CMake project. Guess "make" and "make install" and "make test". |
| if("${CMAKE_GENERATOR}" MATCHES "Makefiles") |
| # Try to get the parallel arguments |
| set(cmd "$(MAKE)") |
| else() |
| set(cmd "make") |
| endif() |
| if(step STREQUAL "INSTALL") |
| set(args install) |
| endif() |
| if(step STREQUAL "TEST") |
| set(args test) |
| endif() |
| endif() |
| |
| # Use user-specified arguments instead of default arguments, if any. |
| get_property(have_args TARGET ${name} PROPERTY _EP_${step}_ARGS SET) |
| if(have_args) |
| get_target_property(args ${name} _EP_${step}_ARGS) |
| endif() |
| |
| list(APPEND cmd ${args}) |
| endif() |
| |
| set(${cmd_var} "${cmd}" PARENT_SCOPE) |
| endfunction() |
| |
| function(_ep_write_log_script name step cmd_var) |
| ExternalProject_Get_Property(${name} stamp_dir) |
| set(command "${${cmd_var}}") |
| |
| set(make "") |
| set(code_cygpath_make "") |
| if(command MATCHES "^\\$\\(MAKE\\)") |
| # GNU make recognizes the string "$(MAKE)" as recursive make, so |
| # ensure that it appears directly in the makefile. |
| string(REGEX REPLACE "^\\$\\(MAKE\\)" "\${make}" command "${command}") |
| set(make "-Dmake=$(MAKE)") |
| |
| if(WIN32 AND NOT CYGWIN) |
| set(code_cygpath_make " |
| if(\${make} MATCHES \"^/\") |
| execute_process( |
| COMMAND cygpath -w \${make} |
| OUTPUT_VARIABLE cygpath_make |
| ERROR_VARIABLE cygpath_make |
| RESULT_VARIABLE cygpath_error |
| OUTPUT_STRIP_TRAILING_WHITESPACE |
| ) |
| if(NOT cygpath_error) |
| set(make \${cygpath_make}) |
| endif() |
| endif() |
| ") |
| endif() |
| endif() |
| |
| set(config "") |
| if("${CMAKE_CFG_INTDIR}" MATCHES "^\\$") |
| string(REPLACE "${CMAKE_CFG_INTDIR}" "\${config}" command "${command}") |
| set(config "-Dconfig=${CMAKE_CFG_INTDIR}") |
| endif() |
| |
| # Wrap multiple 'COMMAND' lines up into a second-level wrapper |
| # script so all output can be sent to one log file. |
| if(command MATCHES ";COMMAND;") |
| set(code_execute_process " |
| ${code_cygpath_make} |
| execute_process(COMMAND \${command} RESULT_VARIABLE result) |
| if(result) |
| set(msg \"Command failed (\${result}):\\n\") |
| foreach(arg IN LISTS command) |
| set(msg \"\${msg} '\${arg}'\") |
| endforeach() |
| message(FATAL_ERROR \"\${msg}\") |
| endif() |
| ") |
| set(code "") |
| set(cmd "") |
| set(sep "") |
| foreach(arg IN LISTS command) |
| if("x${arg}" STREQUAL "xCOMMAND") |
| set(code "${code}set(command \"${cmd}\")${code_execute_process}") |
| set(cmd "") |
| set(sep "") |
| else() |
| set(cmd "${cmd}${sep}${arg}") |
| set(sep ";") |
| endif() |
| endforeach() |
| set(code "${code}set(command \"${cmd}\")${code_execute_process}") |
| file(WRITE ${stamp_dir}/${name}-${step}-impl.cmake "${code}") |
| set(command ${CMAKE_COMMAND} "-Dmake=\${make}" "-Dconfig=\${config}" -P ${stamp_dir}/${name}-${step}-impl.cmake) |
| endif() |
| |
| # Wrap the command in a script to log output to files. |
| set(script ${stamp_dir}/${name}-${step}.cmake) |
| set(logbase ${stamp_dir}/${name}-${step}) |
| file(WRITE ${script} " |
| ${code_cygpath_make} |
| set(command \"${command}\") |
| execute_process( |
| COMMAND \${command} |
| RESULT_VARIABLE result |
| OUTPUT_FILE \"${logbase}-out.log\" |
| ERROR_FILE \"${logbase}-err.log\" |
| ) |
| if(result) |
| set(msg \"Command failed: \${result}\\n\") |
| foreach(arg IN LISTS command) |
| set(msg \"\${msg} '\${arg}'\") |
| endforeach() |
| set(msg \"\${msg}\\nSee also\\n ${logbase}-*.log\") |
| message(FATAL_ERROR \"\${msg}\") |
| else() |
| set(msg \"${name} ${step} command succeeded. See also ${logbase}-*.log\") |
| message(STATUS \"\${msg}\") |
| endif() |
| ") |
| set(command ${CMAKE_COMMAND} ${make} ${config} -P ${script}) |
| set(${cmd_var} "${command}" PARENT_SCOPE) |
| endfunction() |
| |
| # This module used to use "/${CMAKE_CFG_INTDIR}" directly and produced |
| # makefiles with "/./" in paths for custom command dependencies. Which |
| # resulted in problems with parallel make -j invocations. |
| # |
| # This function was added so that the suffix (search below for ${cfgdir}) is |
| # only set to "/${CMAKE_CFG_INTDIR}" when ${CMAKE_CFG_INTDIR} is not going to |
| # be "." (multi-configuration build systems like Visual Studio and Xcode...) |
| # |
| function(_ep_get_configuration_subdir_suffix suffix_var) |
| set(suffix "") |
| if(CMAKE_CONFIGURATION_TYPES) |
| set(suffix "/${CMAKE_CFG_INTDIR}") |
| endif() |
| set(${suffix_var} "${suffix}" PARENT_SCOPE) |
| endfunction() |
| |
| |
| function(_ep_get_step_stampfile name step stampfile_var) |
| ExternalProject_Get_Property(${name} stamp_dir) |
| |
| _ep_get_configuration_subdir_suffix(cfgdir) |
| set(stampfile "${stamp_dir}${cfgdir}/${name}-${step}") |
| |
| set(${stampfile_var} "${stampfile}" PARENT_SCOPE) |
| endfunction() |
| |
| |
| function(ExternalProject_Add_StepTargets name) |
| set(steps ${ARGN}) |
| if("${ARGV1}" STREQUAL "NO_DEPENDS") |
| set(no_deps 1) |
| list(REMOVE_AT steps 0) |
| endif() |
| foreach(step ${steps}) |
| if(no_deps AND "${step}" MATCHES "^(configure|build|install|test)$") |
| message(AUTHOR_WARNING "Using NO_DEPENDS for \"${step}\" step might break parallel builds") |
| endif() |
| _ep_get_step_stampfile(${name} ${step} stamp_file) |
| add_custom_target(${name}-${step} |
| DEPENDS ${stamp_file}) |
| set_property(TARGET ${name}-${step} PROPERTY _EP_IS_EXTERNAL_PROJECT_STEP 1) |
| set_property(TARGET ${name}-${step} PROPERTY LABELS ${name}) |
| set_property(TARGET ${name}-${step} PROPERTY FOLDER "ExternalProjectTargets/${name}") |
| |
| # Depend on other external projects (target-level). |
| if(NOT no_deps) |
| get_property(deps TARGET ${name} PROPERTY _EP_DEPENDS) |
| foreach(arg IN LISTS deps) |
| add_dependencies(${name}-${step} ${arg}) |
| endforeach() |
| endif() |
| endforeach() |
| endfunction() |
| |
| |
| function(ExternalProject_Add_Step name step) |
| set(cmf_dir ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles) |
| _ep_get_configuration_subdir_suffix(cfgdir) |
| |
| set(complete_stamp_file "${cmf_dir}${cfgdir}/${name}-complete") |
| _ep_get_step_stampfile(${name} ${step} stamp_file) |
| |
| _ep_parse_arguments(ExternalProject_Add_Step |
| ${name} _EP_${step}_ "${ARGN}") |
| |
| get_property(exclude_from_main TARGET ${name} PROPERTY _EP_${step}_EXCLUDE_FROM_MAIN) |
| if(NOT exclude_from_main) |
| add_custom_command(APPEND |
| OUTPUT ${complete_stamp_file} |
| DEPENDS ${stamp_file} |
| ) |
| endif() |
| |
| # Steps depending on this step. |
| get_property(dependers TARGET ${name} PROPERTY _EP_${step}_DEPENDERS) |
| foreach(depender IN LISTS dependers) |
| _ep_get_step_stampfile(${name} ${depender} depender_stamp_file) |
| add_custom_command(APPEND |
| OUTPUT ${depender_stamp_file} |
| DEPENDS ${stamp_file} |
| ) |
| endforeach() |
| |
| # Dependencies on files. |
| get_property(depends TARGET ${name} PROPERTY _EP_${step}_DEPENDS) |
| |
| # Byproducts of the step. |
| get_property(byproducts TARGET ${name} PROPERTY _EP_${step}_BYPRODUCTS) |
| |
| # Dependencies on steps. |
| get_property(dependees TARGET ${name} PROPERTY _EP_${step}_DEPENDEES) |
| foreach(dependee IN LISTS dependees) |
| _ep_get_step_stampfile(${name} ${dependee} dependee_stamp_file) |
| list(APPEND depends ${dependee_stamp_file}) |
| endforeach() |
| |
| # The command to run. |
| get_property(command TARGET ${name} PROPERTY _EP_${step}_COMMAND) |
| if(command) |
| set(comment "Performing ${step} step for '${name}'") |
| else() |
| set(comment "No ${step} step for '${name}'") |
| endif() |
| get_property(work_dir TARGET ${name} PROPERTY _EP_${step}_WORKING_DIRECTORY) |
| |
| # Replace list separators. |
| get_property(sep TARGET ${name} PROPERTY _EP_LIST_SEPARATOR) |
| if(sep AND command) |
| string(REPLACE "${sep}" "\\;" command "${command}") |
| endif() |
| |
| # Replace location tags. |
| _ep_replace_location_tags(${name} comment command work_dir) |
| |
| # Custom comment? |
| get_property(comment_set TARGET ${name} PROPERTY _EP_${step}_COMMENT SET) |
| if(comment_set) |
| get_property(comment TARGET ${name} PROPERTY _EP_${step}_COMMENT) |
| endif() |
| |
| # Run every time? |
| get_property(always TARGET ${name} PROPERTY _EP_${step}_ALWAYS) |
| if(always) |
| set_property(SOURCE ${stamp_file} PROPERTY SYMBOLIC 1) |
| set(touch) |
| # Remove any existing stamp in case the option changed in an existing tree. |
| if(CMAKE_CONFIGURATION_TYPES) |
| foreach(cfg ${CMAKE_CONFIGURATION_TYPES}) |
| string(REPLACE "/${CMAKE_CFG_INTDIR}" "/${cfg}" stamp_file_config "${stamp_file}") |
| file(REMOVE ${stamp_file_config}) |
| endforeach() |
| else() |
| file(REMOVE ${stamp_file}) |
| endif() |
| else() |
| set(touch ${CMAKE_COMMAND} -E touch ${stamp_file}) |
| endif() |
| |
| # Wrap with log script? |
| get_property(log TARGET ${name} PROPERTY _EP_${step}_LOG) |
| if(command AND log) |
| _ep_write_log_script(${name} ${step} command) |
| endif() |
| |
| if("${command}" STREQUAL "") |
| # Some generators (i.e. Xcode) will not generate a file level target |
| # if no command is set, and therefore the dependencies on this |
| # target will be broken. |
| # The empty command is replaced by an echo command here in order to |
| # avoid this issue. |
| set(command ${CMAKE_COMMAND} -E echo_append) |
| endif() |
| |
| add_custom_command( |
| OUTPUT ${stamp_file} |
| BYPRODUCTS ${byproducts} |
| COMMENT ${comment} |
| COMMAND ${command} |
| COMMAND ${touch} |
| DEPENDS ${depends} |
| WORKING_DIRECTORY ${work_dir} |
| VERBATIM |
| ) |
| set_property(TARGET ${name} APPEND PROPERTY _EP_STEPS ${step}) |
| |
| # Add custom "step target"? |
| get_property(step_targets TARGET ${name} PROPERTY _EP_STEP_TARGETS) |
| if(NOT step_targets) |
| get_property(step_targets DIRECTORY PROPERTY EP_STEP_TARGETS) |
| endif() |
| foreach(st ${step_targets}) |
| if("${st}" STREQUAL "${step}") |
| ExternalProject_Add_StepTargets(${name} ${step}) |
| break() |
| endif() |
| endforeach() |
| |
| get_property(independent_step_targets TARGET ${name} PROPERTY _EP_INDEPENDENT_STEP_TARGETS) |
| if(NOT independent_step_targets) |
| get_property(independent_step_targets DIRECTORY PROPERTY EP_INDEPENDENT_STEP_TARGETS) |
| endif() |
| foreach(st ${independent_step_targets}) |
| if("${st}" STREQUAL "${step}") |
| ExternalProject_Add_StepTargets(${name} NO_DEPENDS ${step}) |
| break() |
| endif() |
| endforeach() |
| endfunction() |
| |
| |
| function(ExternalProject_Add_StepDependencies name step) |
| set(dependencies ${ARGN}) |
| |
| # Sanity checks on "name" and "step". |
| if(NOT TARGET ${name}) |
| message(FATAL_ERROR "Cannot find target \"${name}\". Perhaps it has not yet been created using ExternalProject_Add.") |
| endif() |
| |
| get_property(is_ep TARGET ${name} PROPERTY _EP_IS_EXTERNAL_PROJECT) |
| if(NOT is_ep) |
| message(FATAL_ERROR "Target \"${name}\" was not generated by ExternalProject_Add.") |
| endif() |
| |
| get_property(steps TARGET ${name} PROPERTY _EP_STEPS) |
| list(FIND steps ${step} is_step) |
| if(NOT is_step) |
| message(FATAL_ERROR "External project \"${name}\" does not have a step \"${step}\".") |
| endif() |
| |
| if(TARGET ${name}-${step}) |
| get_property(is_ep_step TARGET ${name}-${step} PROPERTY _EP_IS_EXTERNAL_PROJECT_STEP) |
| if(NOT is_ep_step) |
| message(FATAL_ERROR "Target \"${name}\" was not generated by ExternalProject_Add_StepTargets.") |
| endif() |
| endif() |
| |
| # Always add file-level dependency, but add target-level dependency |
| # only if the target exists for that step. |
| _ep_get_step_stampfile(${name} ${step} stamp_file) |
| foreach(dep ${dependencies}) |
| add_custom_command(APPEND |
| OUTPUT ${stamp_file} |
| DEPENDS ${dep}) |
| if(TARGET ${name}-${step}) |
| foreach(dep ${dependencies}) |
| add_dependencies(${name}-${step} ${dep}) |
| endforeach() |
| endif() |
| endforeach() |
| |
| endfunction() |
| |
| |
| function(_ep_add_mkdir_command name) |
| ExternalProject_Get_Property(${name} |
| source_dir binary_dir install_dir stamp_dir download_dir tmp_dir) |
| |
| _ep_get_configuration_subdir_suffix(cfgdir) |
| |
| ExternalProject_Add_Step(${name} mkdir |
| COMMENT "Creating directories for '${name}'" |
| COMMAND ${CMAKE_COMMAND} -E make_directory ${source_dir} |
| COMMAND ${CMAKE_COMMAND} -E make_directory ${binary_dir} |
| COMMAND ${CMAKE_COMMAND} -E make_directory ${install_dir} |
| COMMAND ${CMAKE_COMMAND} -E make_directory ${tmp_dir} |
| COMMAND ${CMAKE_COMMAND} -E make_directory ${stamp_dir}${cfgdir} |
| COMMAND ${CMAKE_COMMAND} -E make_directory ${download_dir} |
| ) |
| endfunction() |
| |
| |
| function(_ep_get_git_version git_EXECUTABLE git_version_var) |
| if(git_EXECUTABLE) |
| execute_process( |
| COMMAND "${git_EXECUTABLE}" --version |
| OUTPUT_VARIABLE ov |
| ERROR_VARIABLE ev |
| OUTPUT_STRIP_TRAILING_WHITESPACE |
| ) |
| string(REGEX REPLACE "^git version (.+)$" "\\1" version "${ov}") |
| set(${git_version_var} "${version}" PARENT_SCOPE) |
| endif() |
| endfunction() |
| |
| |
| function(_ep_is_dir_empty dir empty_var) |
| file(GLOB gr "${dir}/*") |
| if("${gr}" STREQUAL "") |
| set(${empty_var} 1 PARENT_SCOPE) |
| else() |
| set(${empty_var} 0 PARENT_SCOPE) |
| endif() |
| endfunction() |
| |
| |
| function(_ep_add_download_command name) |
| ExternalProject_Get_Property(${name} source_dir stamp_dir download_dir tmp_dir) |
| |
| get_property(cmd_set TARGET ${name} PROPERTY _EP_DOWNLOAD_COMMAND SET) |
| get_property(cmd TARGET ${name} PROPERTY _EP_DOWNLOAD_COMMAND) |
| get_property(cvs_repository TARGET ${name} PROPERTY _EP_CVS_REPOSITORY) |
| get_property(svn_repository TARGET ${name} PROPERTY _EP_SVN_REPOSITORY) |
| get_property(git_repository TARGET ${name} PROPERTY _EP_GIT_REPOSITORY) |
| get_property(hg_repository TARGET ${name} PROPERTY _EP_HG_REPOSITORY ) |
| get_property(url TARGET ${name} PROPERTY _EP_URL) |
| get_property(fname TARGET ${name} PROPERTY _EP_DOWNLOAD_NAME) |
| |
| # TODO: Perhaps file:// should be copied to download dir before extraction. |
| string(REGEX REPLACE "^file://" "" url "${url}") |
| |
| set(depends) |
| set(comment) |
| set(work_dir) |
| |
| if(cmd_set) |
| set(work_dir ${download_dir}) |
| elseif(cvs_repository) |
| find_package(CVS QUIET) |
| if(NOT CVS_EXECUTABLE) |
| message(FATAL_ERROR "error: could not find cvs for checkout of ${name}") |
| endif() |
| |
| get_target_property(cvs_module ${name} _EP_CVS_MODULE) |
| if(NOT cvs_module) |
| message(FATAL_ERROR "error: no CVS_MODULE") |
| endif() |
| |
| get_property(cvs_tag TARGET ${name} PROPERTY _EP_CVS_TAG) |
| |
| set(repository ${cvs_repository}) |
| set(module ${cvs_module}) |
| set(tag ${cvs_tag}) |
| configure_file( |
| "${CMAKE_ROOT}/Modules/RepositoryInfo.txt.in" |
| "${stamp_dir}/${name}-cvsinfo.txt" |
| @ONLY |
| ) |
| |
| get_filename_component(src_name "${source_dir}" NAME) |
| get_filename_component(work_dir "${source_dir}" PATH) |
| set(comment "Performing download step (CVS checkout) for '${name}'") |
| set(cmd ${CVS_EXECUTABLE} -d ${cvs_repository} -q co ${cvs_tag} -d ${src_name} ${cvs_module}) |
| list(APPEND depends ${stamp_dir}/${name}-cvsinfo.txt) |
| elseif(svn_repository) |
| find_package(Subversion QUIET) |
| if(NOT Subversion_SVN_EXECUTABLE) |
| message(FATAL_ERROR "error: could not find svn for checkout of ${name}") |
| endif() |
| |
| get_property(svn_revision TARGET ${name} PROPERTY _EP_SVN_REVISION) |
| get_property(svn_username TARGET ${name} PROPERTY _EP_SVN_USERNAME) |
| get_property(svn_password TARGET ${name} PROPERTY _EP_SVN_PASSWORD) |
| get_property(svn_trust_cert TARGET ${name} PROPERTY _EP_SVN_TRUST_CERT) |
| |
| set(repository "${svn_repository} user=${svn_username} password=${svn_password}") |
| set(module) |
| set(tag ${svn_revision}) |
| configure_file( |
| "${CMAKE_ROOT}/Modules/RepositoryInfo.txt.in" |
| "${stamp_dir}/${name}-svninfo.txt" |
| @ONLY |
| ) |
| |
| get_filename_component(src_name "${source_dir}" NAME) |
| get_filename_component(work_dir "${source_dir}" PATH) |
| set(comment "Performing download step (SVN checkout) for '${name}'") |
| set(svn_user_pw_args "") |
| if(DEFINED svn_username) |
| set(svn_user_pw_args ${svn_user_pw_args} "--username=${svn_username}") |
| endif() |
| if(DEFINED svn_password) |
| set(svn_user_pw_args ${svn_user_pw_args} "--password=${svn_password}") |
| endif() |
| if(svn_trust_cert) |
| set(svn_trust_cert_args --trust-server-cert) |
| endif() |
| set(cmd ${Subversion_SVN_EXECUTABLE} co ${svn_repository} ${svn_revision} |
| --non-interactive ${svn_trust_cert_args} ${svn_user_pw_args} ${src_name}) |
| list(APPEND depends ${stamp_dir}/${name}-svninfo.txt) |
| elseif(git_repository) |
| find_package(Git QUIET) |
| if(NOT GIT_EXECUTABLE) |
| message(FATAL_ERROR "error: could not find git for clone of ${name}") |
| endif() |
| |
| # The git submodule update '--recursive' flag requires git >= v1.6.5 |
| # |
| _ep_get_git_version("${GIT_EXECUTABLE}" git_version) |
| if(git_version VERSION_LESS 1.6.5) |
| message(FATAL_ERROR "error: git version 1.6.5 or later required for 'git submodule update --recursive': git_version='${git_version}'") |
| endif() |
| |
| get_property(git_tag TARGET ${name} PROPERTY _EP_GIT_TAG) |
| if(NOT git_tag) |
| set(git_tag "master") |
| endif() |
| get_property(git_submodules TARGET ${name} PROPERTY _EP_GIT_SUBMODULES) |
| |
| # For the download step, and the git clone operation, only the repository |
| # should be recorded in a configured RepositoryInfo file. If the repo |
| # changes, the clone script should be run again. But if only the tag |
| # changes, avoid running the clone script again. Let the 'always' running |
| # update step checkout the new tag. |
| # |
| set(repository ${git_repository}) |
| set(module) |
| set(tag) |
| configure_file( |
| "${CMAKE_ROOT}/Modules/RepositoryInfo.txt.in" |
| "${stamp_dir}/${name}-gitinfo.txt" |
| @ONLY |
| ) |
| |
| get_filename_component(src_name "${source_dir}" NAME) |
| get_filename_component(work_dir "${source_dir}" PATH) |
| |
| # Since git clone doesn't succeed if the non-empty source_dir exists, |
| # create a cmake script to invoke as download command. |
| # The script will delete the source directory and then call git clone. |
| # |
| _ep_write_gitclone_script(${tmp_dir}/${name}-gitclone.cmake ${source_dir} |
| ${GIT_EXECUTABLE} ${git_repository} ${git_tag} "${git_submodules}" ${src_name} ${work_dir} |
| ${stamp_dir}/${name}-gitinfo.txt ${stamp_dir}/${name}-gitclone-lastrun.txt |
| ) |
| set(comment "Performing download step (git clone) for '${name}'") |
| set(cmd ${CMAKE_COMMAND} -P ${tmp_dir}/${name}-gitclone.cmake) |
| list(APPEND depends ${stamp_dir}/${name}-gitinfo.txt) |
| elseif(hg_repository) |
| find_package(Hg QUIET) |
| if(NOT HG_EXECUTABLE) |
| message(FATAL_ERROR "error: could not find hg for clone of ${name}") |
| endif() |
| |
| get_property(hg_tag TARGET ${name} PROPERTY _EP_HG_TAG) |
| if(NOT hg_tag) |
| set(hg_tag "tip") |
| endif() |
| |
| # For the download step, and the hg clone operation, only the repository |
| # should be recorded in a configured RepositoryInfo file. If the repo |
| # changes, the clone script should be run again. But if only the tag |
| # changes, avoid running the clone script again. Let the 'always' running |
| # update step checkout the new tag. |
| # |
| set(repository ${hg_repository}) |
| set(module) |
| set(tag) |
| configure_file( |
| "${CMAKE_ROOT}/Modules/RepositoryInfo.txt.in" |
| "${stamp_dir}/${name}-hginfo.txt" |
| @ONLY |
| ) |
| |
| get_filename_component(src_name "${source_dir}" NAME) |
| get_filename_component(work_dir "${source_dir}" PATH) |
| |
| # Since hg clone doesn't succeed if the non-empty source_dir exists, |
| # create a cmake script to invoke as download command. |
| # The script will delete the source directory and then call hg clone. |
| # |
| _ep_write_hgclone_script(${tmp_dir}/${name}-hgclone.cmake ${source_dir} |
| ${HG_EXECUTABLE} ${hg_repository} ${hg_tag} ${src_name} ${work_dir} |
| ${stamp_dir}/${name}-hginfo.txt ${stamp_dir}/${name}-hgclone-lastrun.txt |
| ) |
| set(comment "Performing download step (hg clone) for '${name}'") |
| set(cmd ${CMAKE_COMMAND} -P ${tmp_dir}/${name}-hgclone.cmake) |
| list(APPEND depends ${stamp_dir}/${name}-hginfo.txt) |
| elseif(url) |
| get_filename_component(work_dir "${source_dir}" PATH) |
| get_property(hash TARGET ${name} PROPERTY _EP_URL_HASH) |
| if(hash AND NOT "${hash}" MATCHES "${_ep_hash_regex}") |
| message(FATAL_ERROR "URL_HASH is set to\n ${hash}\n" |
| "but must be ALGO=value where ALGO is\n ${_ep_hash_algos}\n" |
| "and value is a hex string.") |
| endif() |
| get_property(md5 TARGET ${name} PROPERTY _EP_URL_MD5) |
| if(md5 AND NOT "MD5=${md5}" MATCHES "${_ep_hash_regex}") |
| message(FATAL_ERROR "URL_MD5 is set to\n ${md5}\nbut must be a hex string.") |
| endif() |
| if(md5 AND NOT hash) |
| set(hash "MD5=${md5}") |
| endif() |
| set(repository "external project URL") |
| set(module "${url}") |
| set(tag "${hash}") |
| set(retries 0) |
| set(download_script "") |
| configure_file( |
| "${CMAKE_ROOT}/Modules/RepositoryInfo.txt.in" |
| "${stamp_dir}/${name}-urlinfo.txt" |
| @ONLY |
| ) |
| list(APPEND depends ${stamp_dir}/${name}-urlinfo.txt) |
| if(IS_DIRECTORY "${url}") |
| get_filename_component(abs_dir "${url}" ABSOLUTE) |
| set(comment "Performing download step (DIR copy) for '${name}'") |
| set(cmd ${CMAKE_COMMAND} -E remove_directory ${source_dir} |
| COMMAND ${CMAKE_COMMAND} -E copy_directory ${abs_dir} ${source_dir}) |
| else() |
| if("${url}" MATCHES "^[a-z]+://") |
| # TODO: Should download and extraction be different steps? |
| if("x${fname}" STREQUAL "x") |
| string(REGEX MATCH "[^/\\?]*$" fname "${url}") |
| endif() |
| if(NOT "${fname}" MATCHES "(\\.|=)(7z|tar|tar\\.bz2|tar\\.gz|tar\\.xz|tbz2|tgz|txz|zip)$") |
| string(REGEX MATCH "([^/\\?]+(\\.|=)(7z|tar|tar\\.bz2|tar\\.gz|tar\\.xz|tbz2|tgz|txz|zip))/.*$" match_result "${url}") |
| set(fname "${CMAKE_MATCH_1}") |
| endif() |
| if(NOT "${fname}" MATCHES "(\\.|=)(7z|tar|tar\\.bz2|tar\\.gz|tar\\.xz|tbz2|tgz|txz|zip)$") |
| message(FATAL_ERROR "Could not extract tarball filename from url:\n ${url}") |
| endif() |
| string(REPLACE ";" "-" fname "${fname}") |
| set(file ${download_dir}/${fname}) |
| get_property(timeout TARGET ${name} PROPERTY _EP_TIMEOUT) |
| get_property(no_progress TARGET ${name} PROPERTY _EP_DOWNLOAD_NO_PROGRESS) |
| get_property(tls_verify TARGET ${name} PROPERTY _EP_TLS_VERIFY) |
| get_property(tls_cainfo TARGET ${name} PROPERTY _EP_TLS_CAINFO) |
| set(download_script "${stamp_dir}/download-${name}.cmake") |
| _ep_write_downloadfile_script("${download_script}" "${url}" "${file}" "${timeout}" "${no_progress}" "${hash}" "${tls_verify}" "${tls_cainfo}") |
| set(cmd ${CMAKE_COMMAND} -P "${download_script}" |
| COMMAND) |
| set(retries 3) |
| set(comment "Performing download step (download, verify and extract) for '${name}'") |
| else() |
| set(file "${url}") |
| set(comment "Performing download step (verify and extract) for '${name}'") |
| endif() |
| _ep_write_verifyfile_script("${stamp_dir}/verify-${name}.cmake" "${file}" "${hash}" "${retries}" "${download_script}") |
| list(APPEND cmd ${CMAKE_COMMAND} -P ${stamp_dir}/verify-${name}.cmake |
| COMMAND) |
| _ep_write_extractfile_script("${stamp_dir}/extract-${name}.cmake" "${name}" "${file}" "${source_dir}") |
| list(APPEND cmd ${CMAKE_COMMAND} -P ${stamp_dir}/extract-${name}.cmake) |
| endif() |
| else() |
| _ep_is_dir_empty("${source_dir}" empty) |
| if(${empty}) |
| message(SEND_ERROR "error: no download info for '${name}' -- please specify existing/non-empty SOURCE_DIR or one of URL, CVS_REPOSITORY and CVS_MODULE, SVN_REPOSITORY, GIT_REPOSITORY, HG_REPOSITORY or DOWNLOAD_COMMAND") |
| endif() |
| endif() |
| |
| get_property(log TARGET ${name} PROPERTY _EP_LOG_DOWNLOAD) |
| if(log) |
| set(log LOG 1) |
| else() |
| set(log "") |
| endif() |
| |
| ExternalProject_Add_Step(${name} download |
| COMMENT ${comment} |
| COMMAND ${cmd} |
| WORKING_DIRECTORY ${work_dir} |
| DEPENDS ${depends} |
| DEPENDEES mkdir |
| ${log} |
| ) |
| endfunction() |
| |
| |
| function(_ep_add_update_command name) |
| ExternalProject_Get_Property(${name} source_dir tmp_dir) |
| |
| get_property(cmd_set TARGET ${name} PROPERTY _EP_UPDATE_COMMAND SET) |
| get_property(cmd TARGET ${name} PROPERTY _EP_UPDATE_COMMAND) |
| get_property(cvs_repository TARGET ${name} PROPERTY _EP_CVS_REPOSITORY) |
| get_property(svn_repository TARGET ${name} PROPERTY _EP_SVN_REPOSITORY) |
| get_property(git_repository TARGET ${name} PROPERTY _EP_GIT_REPOSITORY) |
| get_property(hg_repository TARGET ${name} PROPERTY _EP_HG_REPOSITORY ) |
| get_property(update_disconnected_set TARGET ${name} PROPERTY _EP_UPDATE_DISCONNECTED SET) |
| if(update_disconnected_set) |
| get_property(update_disconnected TARGET ${name} PROPERTY _EP_UPDATE_DISCONNECTED) |
| else() |
| get_property(update_disconnected DIRECTORY PROPERTY EP_UPDATE_DISCONNECTED) |
| endif() |
| |
| set(work_dir) |
| set(comment) |
| set(always) |
| |
| if(cmd_set) |
| set(work_dir ${source_dir}) |
| elseif(cvs_repository) |
| if(NOT CVS_EXECUTABLE) |
| message(FATAL_ERROR "error: could not find cvs for update of ${name}") |
| endif() |
| set(work_dir ${source_dir}) |
| set(comment "Performing update step (CVS update) for '${name}'") |
| get_property(cvs_tag TARGET ${name} PROPERTY _EP_CVS_TAG) |
| set(cmd ${CVS_EXECUTABLE} -d ${cvs_repository} -q up -dP ${cvs_tag}) |
| set(always 1) |
| elseif(svn_repository) |
| if(NOT Subversion_SVN_EXECUTABLE) |
| message(FATAL_ERROR "error: could not find svn for update of ${name}") |
| endif() |
| set(work_dir ${source_dir}) |
| set(comment "Performing update step (SVN update) for '${name}'") |
| get_property(svn_revision TARGET ${name} PROPERTY _EP_SVN_REVISION) |
| get_property(svn_username TARGET ${name} PROPERTY _EP_SVN_USERNAME) |
| get_property(svn_password TARGET ${name} PROPERTY _EP_SVN_PASSWORD) |
| get_property(svn_trust_cert TARGET ${name} PROPERTY _EP_SVN_TRUST_CERT) |
| set(svn_user_pw_args "") |
| if(DEFINED svn_username) |
| set(svn_user_pw_args ${svn_user_pw_args} "--username=${svn_username}") |
| endif() |
| if(DEFINED svn_password) |
| set(svn_user_pw_args ${svn_user_pw_args} "--password=${svn_password}") |
| endif() |
| if(svn_trust_cert) |
| set(svn_trust_cert_args --trust-server-cert) |
| endif() |
| set(cmd ${Subversion_SVN_EXECUTABLE} up ${svn_revision} |
| --non-interactive ${svn_trust_cert_args} ${svn_user_pw_args}) |
| set(always 1) |
| elseif(git_repository) |
| if(NOT GIT_EXECUTABLE) |
| message(FATAL_ERROR "error: could not find git for fetch of ${name}") |
| endif() |
| set(work_dir ${source_dir}) |
| set(comment "Performing update step for '${name}'") |
| get_property(git_tag TARGET ${name} PROPERTY _EP_GIT_TAG) |
| if(NOT git_tag) |
| set(git_tag "master") |
| endif() |
| get_property(git_submodules TARGET ${name} PROPERTY _EP_GIT_SUBMODULES) |
| _ep_write_gitupdate_script(${tmp_dir}/${name}-gitupdate.cmake |
| ${GIT_EXECUTABLE} ${git_tag} "${git_submodules}" ${git_repository} ${work_dir} |
| ) |
| set(cmd ${CMAKE_COMMAND} -P ${tmp_dir}/${name}-gitupdate.cmake) |
| set(always 1) |
| elseif(hg_repository) |
| if(NOT HG_EXECUTABLE) |
| message(FATAL_ERROR "error: could not find hg for pull of ${name}") |
| endif() |
| set(work_dir ${source_dir}) |
| set(comment "Performing update step (hg pull) for '${name}'") |
| get_property(hg_tag TARGET ${name} PROPERTY _EP_HG_TAG) |
| if(NOT hg_tag) |
| set(hg_tag "tip") |
| endif() |
| if("${HG_VERSION_STRING}" STREQUAL "2.1") |
| message(WARNING "Mercurial 2.1 does not distinguish an empty pull from a failed pull: |
| http://mercurial.selenic.com/wiki/UpgradeNotes#A2.1.1:_revert_pull_return_code_change.2C_compile_issue_on_OS_X |
| http://thread.gmane.org/gmane.comp.version-control.mercurial.devel/47656 |
| Update to Mercurial >= 2.1.1. |
| ") |
| endif() |
| set(cmd ${HG_EXECUTABLE} pull |
| COMMAND ${HG_EXECUTABLE} update ${hg_tag} |
| ) |
| set(always 1) |
| endif() |
| |
| get_property(log TARGET ${name} PROPERTY _EP_LOG_UPDATE) |
| if(log) |
| set(log LOG 1) |
| else() |
| set(log "") |
| endif() |
| |
| ExternalProject_Add_Step(${name} update |
| COMMENT ${comment} |
| COMMAND ${cmd} |
| ALWAYS ${always} |
| EXCLUDE_FROM_MAIN ${update_disconnected} |
| WORKING_DIRECTORY ${work_dir} |
| DEPENDEES download |
| ${log} |
| ) |
| |
| if(always AND update_disconnected) |
| _ep_get_step_stampfile(${name} skip-update skip-update_stamp_file) |
| string(REPLACE "Performing" "Skipping" comment "${comment}") |
| ExternalProject_Add_Step(${name} skip-update |
| COMMENT ${comment} |
| ALWAYS 1 |
| EXCLUDE_FROM_MAIN 1 |
| WORKING_DIRECTORY ${work_dir} |
| DEPENDEES download |
| ${log} |
| ) |
| set_property(SOURCE ${skip-update_stamp_file} PROPERTY SYMBOLIC 1) |
| endif() |
| |
| endfunction() |
| |
| |
| function(_ep_add_patch_command name) |
| ExternalProject_Get_Property(${name} source_dir) |
| |
| get_property(cmd_set TARGET ${name} PROPERTY _EP_PATCH_COMMAND SET) |
| get_property(cmd TARGET ${name} PROPERTY _EP_PATCH_COMMAND) |
| |
| set(work_dir) |
| |
| if(cmd_set) |
| set(work_dir ${source_dir}) |
| endif() |
| |
| ExternalProject_Add_Step(${name} patch |
| COMMAND ${cmd} |
| WORKING_DIRECTORY ${work_dir} |
| DEPENDEES download |
| ) |
| endfunction() |
| |
| |
| # TODO: Make sure external projects use the proper compiler |
| function(_ep_add_configure_command name) |
| ExternalProject_Get_Property(${name} source_dir binary_dir tmp_dir) |
| |
| # Depend on other external projects (file-level). |
| set(file_deps) |
| get_property(deps TARGET ${name} PROPERTY _EP_DEPENDS) |
| foreach(dep IN LISTS deps) |
| get_property(is_ep TARGET ${dep} PROPERTY _EP_IS_EXTERNAL_PROJECT) |
| if(is_ep) |
| _ep_get_step_stampfile(${dep} "done" done_stamp_file) |
| list(APPEND file_deps ${done_stamp_file}) |
| endif() |
| endforeach() |
| |
| get_property(cmd_set TARGET ${name} PROPERTY _EP_CONFIGURE_COMMAND SET) |
| if(cmd_set) |
| get_property(cmd TARGET ${name} PROPERTY _EP_CONFIGURE_COMMAND) |
| else() |
| get_target_property(cmake_command ${name} _EP_CMAKE_COMMAND) |
| if(cmake_command) |
| set(cmd "${cmake_command}") |
| else() |
| set(cmd "${CMAKE_COMMAND}") |
| endif() |
| |
| get_property(cmake_args TARGET ${name} PROPERTY _EP_CMAKE_ARGS) |
| list(APPEND cmd ${cmake_args}) |
| |
| # If there are any CMAKE_CACHE_ARGS or CMAKE_CACHE_DEFAULT_ARGS, |
| # write an initial cache and use it |
| get_property(cmake_cache_args TARGET ${name} PROPERTY _EP_CMAKE_CACHE_ARGS) |
| get_property(cmake_cache_default_args TARGET ${name} PROPERTY _EP_CMAKE_CACHE_DEFAULT_ARGS) |
| |
| if(cmake_cache_args OR cmake_cache_default_args) |
| set(_ep_cache_args_script "${tmp_dir}/${name}-cache.cmake") |
| if(cmake_cache_args) |
| _ep_command_line_to_initial_cache(script_initial_cache_force "${cmake_cache_args}" 1) |
| endif() |
| if(cmake_cache_default_args) |
| _ep_command_line_to_initial_cache(script_initial_cache_default "${cmake_cache_default_args}" 0) |
| endif() |
| _ep_write_initial_cache(${name} "${_ep_cache_args_script}" "${script_initial_cache_force}${script_initial_cache_default}") |
| list(APPEND cmd "-C${_ep_cache_args_script}") |
| endif() |
| |
| get_target_property(cmake_generator ${name} _EP_CMAKE_GENERATOR) |
| get_target_property(cmake_generator_platform ${name} _EP_CMAKE_GENERATOR_PLATFORM) |
| get_target_property(cmake_generator_toolset ${name} _EP_CMAKE_GENERATOR_TOOLSET) |
| if(cmake_generator) |
| list(APPEND cmd "-G${cmake_generator}") |
| if(cmake_generator_platform) |
| list(APPEND cmd "-A${cmake_generator_platform}") |
| endif() |
| if(cmake_generator_toolset) |
| list(APPEND cmd "-T${cmake_generator_toolset}") |
| endif() |
| else() |
| if(CMAKE_EXTRA_GENERATOR) |
| list(APPEND cmd "-G${CMAKE_EXTRA_GENERATOR} - ${CMAKE_GENERATOR}") |
| else() |
| list(APPEND cmd "-G${CMAKE_GENERATOR}") |
| endif() |
| if(cmake_generator_platform) |
| message(FATAL_ERROR "Option CMAKE_GENERATOR_PLATFORM not allowed without CMAKE_GENERATOR.") |
| endif() |
| if(CMAKE_GENERATOR_PLATFORM) |
| list(APPEND cmd "-A${CMAKE_GENERATOR_PLATFORM}") |
| endif() |
| if(cmake_generator_toolset) |
| message(FATAL_ERROR "Option CMAKE_GENERATOR_TOOLSET not allowed without CMAKE_GENERATOR.") |
| endif() |
| if(CMAKE_GENERATOR_TOOLSET) |
| list(APPEND cmd "-T${CMAKE_GENERATOR_TOOLSET}") |
| endif() |
| endif() |
| |
| list(APPEND cmd "${source_dir}") |
| endif() |
| |
| # If anything about the configure command changes, (command itself, cmake |
| # used, cmake args or cmake generator) then re-run the configure step. |
| # Fixes issue http://public.kitware.com/Bug/view.php?id=10258 |
| # |
| if(NOT EXISTS ${tmp_dir}/${name}-cfgcmd.txt.in) |
| file(WRITE ${tmp_dir}/${name}-cfgcmd.txt.in "cmd='\@cmd\@'\n") |
| endif() |
| configure_file(${tmp_dir}/${name}-cfgcmd.txt.in ${tmp_dir}/${name}-cfgcmd.txt) |
| list(APPEND file_deps ${tmp_dir}/${name}-cfgcmd.txt) |
| list(APPEND file_deps ${_ep_cache_args_script}) |
| |
| get_property(log TARGET ${name} PROPERTY _EP_LOG_CONFIGURE) |
| if(log) |
| set(log LOG 1) |
| else() |
| set(log "") |
| endif() |
| |
| get_property(update_disconnected_set TARGET ${name} PROPERTY _EP_UPDATE_DISCONNECTED SET) |
| if(update_disconnected_set) |
| get_property(update_disconnected TARGET ${name} PROPERTY _EP_UPDATE_DISCONNECTED) |
| else() |
| get_property(update_disconnected DIRECTORY PROPERTY EP_UPDATE_DISCONNECTED) |
| endif() |
| if(update_disconnected) |
| set(update_dep skip-update) |
| else() |
| set(update_dep update) |
| endif() |
| |
| ExternalProject_Add_Step(${name} configure |
| COMMAND ${cmd} |
| WORKING_DIRECTORY ${binary_dir} |
| DEPENDEES ${update_dep} patch |
| DEPENDS ${file_deps} |
| ${log} |
| ) |
| endfunction() |
| |
| |
| function(_ep_add_build_command name) |
| ExternalProject_Get_Property(${name} binary_dir) |
| |
| get_property(cmd_set TARGET ${name} PROPERTY _EP_BUILD_COMMAND SET) |
| if(cmd_set) |
| get_property(cmd TARGET ${name} PROPERTY _EP_BUILD_COMMAND) |
| else() |
| _ep_get_build_command(${name} BUILD cmd) |
| endif() |
| |
| get_property(log TARGET ${name} PROPERTY _EP_LOG_BUILD) |
| if(log) |
| set(log LOG 1) |
| else() |
| set(log "") |
| endif() |
| |
| get_property(build_always TARGET ${name} PROPERTY _EP_BUILD_ALWAYS) |
| if(build_always) |
| set(always 1) |
| else() |
| set(always 0) |
| endif() |
| |
| get_property(build_byproducts TARGET ${name} PROPERTY _EP_BUILD_BYPRODUCTS) |
| |
| ExternalProject_Add_Step(${name} build |
| COMMAND ${cmd} |
| BYPRODUCTS ${build_byproducts} |
| WORKING_DIRECTORY ${binary_dir} |
| DEPENDEES configure |
| ALWAYS ${always} |
| ${log} |
| ) |
| endfunction() |
| |
| |
| function(_ep_add_install_command name) |
| ExternalProject_Get_Property(${name} binary_dir) |
| |
| get_property(cmd_set TARGET ${name} PROPERTY _EP_INSTALL_COMMAND SET) |
| if(cmd_set) |
| get_property(cmd TARGET ${name} PROPERTY _EP_INSTALL_COMMAND) |
| else() |
| _ep_get_build_command(${name} INSTALL cmd) |
| endif() |
| |
| get_property(log TARGET ${name} PROPERTY _EP_LOG_INSTALL) |
| if(log) |
| set(log LOG 1) |
| else() |
| set(log "") |
| endif() |
| |
| ExternalProject_Add_Step(${name} install |
| COMMAND ${cmd} |
| WORKING_DIRECTORY ${binary_dir} |
| DEPENDEES build |
| ${log} |
| ) |
| endfunction() |
| |
| |
| function(_ep_add_test_command name) |
| ExternalProject_Get_Property(${name} binary_dir) |
| |
| get_property(before TARGET ${name} PROPERTY _EP_TEST_BEFORE_INSTALL) |
| get_property(after TARGET ${name} PROPERTY _EP_TEST_AFTER_INSTALL) |
| get_property(exclude TARGET ${name} PROPERTY _EP_TEST_EXCLUDE_FROM_MAIN) |
| get_property(cmd_set TARGET ${name} PROPERTY _EP_TEST_COMMAND SET) |
| |
| # Only actually add the test step if one of the test related properties is |
| # explicitly set. (i.e. the test step is omitted unless requested...) |
| # |
| if(cmd_set OR before OR after OR exclude) |
| if(cmd_set) |
| get_property(cmd TARGET ${name} PROPERTY _EP_TEST_COMMAND) |
| else() |
| _ep_get_build_command(${name} TEST cmd) |
| endif() |
| |
| if(before) |
| set(dependees_args DEPENDEES build) |
| else() |
| set(dependees_args DEPENDEES install) |
| endif() |
| |
| if(exclude) |
| set(dependers_args "") |
| set(exclude_args EXCLUDE_FROM_MAIN 1) |
| else() |
| if(before) |
| set(dependers_args DEPENDERS install) |
| else() |
| set(dependers_args "") |
| endif() |
| set(exclude_args "") |
| endif() |
| |
| get_property(log TARGET ${name} PROPERTY _EP_LOG_TEST) |
| if(log) |
| set(log LOG 1) |
| else() |
| set(log "") |
| endif() |
| |
| ExternalProject_Add_Step(${name} test |
| COMMAND ${cmd} |
| WORKING_DIRECTORY ${binary_dir} |
| ${dependees_args} |
| ${dependers_args} |
| ${exclude_args} |
| ${log} |
| ) |
| endif() |
| endfunction() |
| |
| |
| function(ExternalProject_Add name) |
| _ep_get_configuration_subdir_suffix(cfgdir) |
| |
| # Add a custom target for the external project. |
| set(cmf_dir ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles) |
| set(complete_stamp_file "${cmf_dir}${cfgdir}/${name}-complete") |
| |
| # The "ALL" option to add_custom_target just tells it to not set the |
| # EXCLUDE_FROM_ALL target property. Later, if the EXCLUDE_FROM_ALL |
| # argument was passed, we explicitly set it for the target. |
| add_custom_target(${name} ALL DEPENDS ${complete_stamp_file}) |
| set_property(TARGET ${name} PROPERTY _EP_IS_EXTERNAL_PROJECT 1) |
| set_property(TARGET ${name} PROPERTY LABELS ${name}) |
| set_property(TARGET ${name} PROPERTY FOLDER "ExternalProjectTargets/${name}") |
| |
| _ep_parse_arguments(ExternalProject_Add ${name} _EP_ "${ARGN}") |
| _ep_set_directories(${name}) |
| _ep_get_step_stampfile(${name} "done" done_stamp_file) |
| _ep_get_step_stampfile(${name} "install" install_stamp_file) |
| |
| # Set the EXCLUDE_FROM_ALL target property if required. |
| get_property(exclude_from_all TARGET ${name} PROPERTY _EP_EXCLUDE_FROM_ALL) |
| if(exclude_from_all) |
| set_property(TARGET ${name} PROPERTY EXCLUDE_FROM_ALL TRUE) |
| endif() |
| |
| # The 'complete' step depends on all other steps and creates a |
| # 'done' mark. A dependent external project's 'configure' step |
| # depends on the 'done' mark so that it rebuilds when this project |
| # rebuilds. It is important that 'done' is not the output of any |
| # custom command so that CMake does not propagate build rules to |
| # other external project targets, which may cause problems during |
| # parallel builds. However, the Ninja generator needs to see the entire |
| # dependency graph, and can cope with custom commands belonging to |
| # multiple targets, so we add the 'done' mark as an output for Ninja only. |
| set(complete_outputs ${complete_stamp_file}) |
| if(${CMAKE_GENERATOR} MATCHES "Ninja") |
| set(complete_outputs ${complete_outputs} ${done_stamp_file}) |
| endif() |
| |
| add_custom_command( |
| OUTPUT ${complete_outputs} |
| COMMENT "Completed '${name}'" |
| COMMAND ${CMAKE_COMMAND} -E make_directory ${cmf_dir}${cfgdir} |
| COMMAND ${CMAKE_COMMAND} -E touch ${complete_stamp_file} |
| COMMAND ${CMAKE_COMMAND} -E touch ${done_stamp_file} |
| DEPENDS ${install_stamp_file} |
| VERBATIM |
| ) |
| |
| |
| # Depend on other external projects (target-level). |
| get_property(deps TARGET ${name} PROPERTY _EP_DEPENDS) |
| foreach(arg IN LISTS deps) |
| add_dependencies(${name} ${arg}) |
| endforeach() |
| |
| # Set up custom build steps based on the target properties. |
| # Each step depends on the previous one. |
| # |
| # The target depends on the output of the final step. |
| # (Already set up above in the DEPENDS of the add_custom_target command.) |
| # |
| _ep_add_mkdir_command(${name}) |
| _ep_add_download_command(${name}) |
| _ep_add_update_command(${name}) |
| _ep_add_patch_command(${name}) |
| _ep_add_configure_command(${name}) |
| _ep_add_build_command(${name}) |
| _ep_add_install_command(${name}) |
| |
| # Test is special in that it might depend on build, or it might depend |
| # on install. |
| # |
| _ep_add_test_command(${name}) |
| endfunction() |