kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
CMake/Modules/ExternalProject.cmake

2368 lines
79 KiB
CMake
Raw Normal View History

ExternalProject: Convert docs to a bracket comment Use a bracket comment to hold the documentation instead of a block of line comments. This will make further updates easier. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:40:22 +03:00
#[=======================================================================[.rst:
ExternalProject
---------------
Create custom targets to build projects in external trees
ExternalProject: Use explicit markup and definition lists in docs Convert ExternalProject module documentation to use explicit markup blocks for each command. Enumerate command options with definition lists instead of a literal block. This will allow more detail to be added later. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:44:00 +03:00
.. 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
ExternalProject: Add UPDATE_DISCONNECTED option 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.
2014-11-05 02:31:40 +03:00
``UPDATE_DISCONNECTED 1``
Never update automatically from the remote repository
ExternalProject: Use explicit markup and definition lists in docs Convert ExternalProject module documentation to use explicit markup blocks for each command. Enumerate command options with definition lists instead of a literal block. This will allow more detail to be added later. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:44:00 +03:00
``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>...``
ExternalProject: Add CMAKE_CACHE_DEFAULT_ARGS arguments This argument allows to set default arguments that are written in the initial cache file, but that are not forced, and therefore allows the user to change these values later (CMAKE_ARGS and CMAKE_CACHE_ARGS always overwrite the values). Also add some documentation to explain the differences between these 3 arguments. Extend ExternalProjectLocal test to cover CMAKE_CACHE_DEFAULT_ARGS.
2014-10-28 12:52:16 +03:00
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.
ExternalProject: Allow generator expressions with LOG_* options (#15287) Use file(GENERATE) to write the logging wrapper scripts to evaluate generator expressions. Use a per-config script names in case the content varies by configuration.
2015-04-21 09:28:21 +03:00
Arguments may use
:manual:`generator expressions <cmake-generator-expressions(7)>`.
ExternalProject: Use explicit markup and definition lists in docs Convert ExternalProject module documentation to use explicit markup blocks for each command. Enumerate command options with definition lists instead of a literal block. This will allow more detail to be added later. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:44:00 +03:00
``CMAKE_CACHE_ARGS <arg>...``
ExternalProject: Add CMAKE_CACHE_DEFAULT_ARGS arguments This argument allows to set default arguments that are written in the initial cache file, but that are not forced, and therefore allows the user to change these values later (CMAKE_ARGS and CMAKE_CACHE_ARGS always overwrite the values). Also add some documentation to explain the differences between these 3 arguments. Extend ExternalProjectLocal test to cover CMAKE_CACHE_DEFAULT_ARGS.
2014-10-28 12:52:16 +03:00
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.
ExternalProject: Allow generator expressions in initial cache options Use file(GENERATE) to write the initial cache file so that we can evaluate generator expressions. Use a per-config initial cache file name in case the content varies by configuration.
2015-04-17 07:42:19 +03:00
Arguments may use
:manual:`generator expressions <cmake-generator-expressions(7)>`.
ExternalProject: Add CMAKE_CACHE_DEFAULT_ARGS arguments This argument allows to set default arguments that are written in the initial cache file, but that are not forced, and therefore allows the user to change these values later (CMAKE_ARGS and CMAKE_CACHE_ARGS always overwrite the values). Also add some documentation to explain the differences between these 3 arguments. Extend ExternalProjectLocal test to cover CMAKE_CACHE_DEFAULT_ARGS.
2014-10-28 12:52:16 +03:00
``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.
ExternalProject: Allow generator expressions in initial cache options Use file(GENERATE) to write the initial cache file so that we can evaluate generator expressions. Use a per-config initial cache file name in case the content varies by configuration.
2015-04-17 07:42:19 +03:00
Arguments may use
:manual:`generator expressions <cmake-generator-expressions(7)>`.
ExternalProject: Use explicit markup and definition lists in docs Convert ExternalProject module documentation to use explicit markup blocks for each command. Enumerate command options with definition lists instead of a literal block. This will allow more detail to be added later. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:44:00 +03:00
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
ExternalProject: Add options to specify BYPRODUCTS (#14963) The external project's build process may generate byproducts on which other rules in the driving project's build later depend. Provide a way for the driving project to specify what byproducts it expects to be made available by the custom commands that drive the external project.
2014-11-14 03:26:36 +03:00
``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.
ExternalProject: Use explicit markup and definition lists in docs Convert ExternalProject module documentation to use explicit markup blocks for each command. Enumerate command options with definition lists instead of a literal block. This will allow more detail to be added later. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:44:00 +03:00
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
ExternalProject: Add TEST_EXCLUDE_FROM_MAIN option If this option is enabled, the test step is created with the EXCLUDE_FROM_MAIN option, and if TEST_BEFORE_INSTALL is enabled, the install step does not depend on the test step. This means that the test step is never executed, unless the test target is explicitly created by calling ExternalProject_Add_StepTarget, or by passing it with the STEP_TARGETS option, or with the EP_STEP_TARGETS directory property.
2014-12-01 00:28:43 +03:00
``TEST_EXCLUDE_FROM_MAIN 1``
Main target does not depend on the test step
ExternalProject: Use explicit markup and definition lists in docs Convert ExternalProject module documentation to use explicit markup blocks for each command. Enumerate command options with definition lists instead of a literal block. This will allow more detail to be added later. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:44:00 +03:00
``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
ExternalProject: Add independent step targets When adding step targets using ExternalProject_Add_StepTargets, the STEP_TARGETS argument or the EP_STEP_TARGETS property, ExternalProject sets all the dependencies for the main project to that target. Due to this, the update target cannot be used without downloading and building all the dependencies. In order to be able to add step targets that do not depend on other external projects, this patch adds: * An optional "NO_DEPENDS" argument to the ExternalProject_Add_StepTargets function. If this argument is set, then no dependencies are set for the target (file dependencies will still be set). * A new argument INDEPENDENT_STEP_TARGETS to the ExternalProject_Add function and a new directory property EP_INDEPENDENT_STEP_TARGETS that behave like STEP_TARGETS and EP_STEP_TARGETS, but cause the ExternalProject_Add_StepTargets to be called with the NO_DEPENDS argument.
2014-11-03 18:14:35 +03:00
``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
ExternalProject: Use explicit markup and definition lists in docs Convert ExternalProject module documentation to use explicit markup blocks for each command. Enumerate command options with definition lists instead of a literal block. This will allow more detail to be added later. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:44:00 +03:00
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``).
ExternalProject: Add UPDATE_DISCONNECTED option 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.
2014-11-05 02:31:40 +03:00
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.
ExternalProject: Use explicit markup and definition lists in docs Convert ExternalProject module documentation to use explicit markup blocks for each command. Enumerate command options with definition lists instead of a literal block. This will allow more detail to be added later. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:44:00 +03:00
.. 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
ExternalProject: Add options to specify BYPRODUCTS (#14963) The external project's build process may generate byproducts on which other rules in the driving project's build later depend. Provide a way for the driving project to specify what byproducts it expects to be made available by the custom commands that drive the external project.
2014-11-14 03:26:36 +03:00
``BYPRODUCTS <file>...``
Files that will be generated by this step but may or may not
have their modification time updated by subsequent builds.
ExternalProject: Use explicit markup and definition lists in docs Convert ExternalProject module documentation to use explicit markup blocks for each command. Enumerate command options with definition lists instead of a literal block. This will allow more detail to be added later. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:44:00 +03:00
``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
ExternalProject: Replace placeholder tokens in BYPRODUCTS This allows the developer to specify the byproducts relative to the binary directory without the need to set the binary directory location explicitly.
2015-03-06 13:43:16 +03:00
The command line, comment, working directory, and byproducts of every
standard and custom step are processed to replace tokens ``<SOURCE_DIR>``,
ExternalProject: Use explicit markup and definition lists in docs Convert ExternalProject module documentation to use explicit markup blocks for each command. Enumerate command options with definition lists instead of a literal block. This will allow more detail to be added later. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:44:00 +03:00
``<BINARY_DIR>``, ``<INSTALL_DIR>``, and ``<TMP_DIR>`` with
corresponding property values.
ExternalProject: Convert docs to a bracket comment Use a bracket comment to hold the documentation instead of a block of line comments. This will make further updates easier. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:40:22 +03:00
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.
ExternalProject: Allow generator expressions with LOG_* options (#15287) Use file(GENERATE) to write the logging wrapper scripts to evaluate generator expressions. Use a per-config script names in case the content varies by configuration.
2015-04-21 09:28:21 +03:00
Arguments to ``<step>_COMMAND`` or ``COMMAND`` options may use
:manual:`generator expressions <cmake-generator-expressions(7)>`.
ExternalProject: Use explicit markup and definition lists in docs Convert ExternalProject module documentation to use explicit markup blocks for each command. Enumerate command options with definition lists instead of a literal block. This will allow more detail to be added later. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:44:00 +03:00
.. command:: ExternalProject_Get_Property
The ``ExternalProject_Get_Property`` function retrieves external project
target properties::
ExternalProject_Get_Property(<name> [prop1 [prop2 [...]]])
ExternalProject: Convert docs to a bracket comment Use a bracket comment to hold the documentation instead of a block of line comments. This will make further updates easier. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:40:22 +03:00
ExternalProject: Use explicit markup and definition lists in docs Convert ExternalProject module documentation to use explicit markup blocks for each command. Enumerate command options with definition lists instead of a literal block. This will allow more detail to be added later. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:44:00 +03:00
It stores property values in variables of the same name. Property
names correspond to the keyword argument names of
``ExternalProject_Add``.
ExternalProject: Convert docs to a bracket comment Use a bracket comment to hold the documentation instead of a block of line comments. This will make further updates easier. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:40:22 +03:00
ExternalProject: Use explicit markup and definition lists in docs Convert ExternalProject module documentation to use explicit markup blocks for each command. Enumerate command options with definition lists instead of a literal block. This will allow more detail to be added later. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:44:00 +03:00
.. command:: ExternalProject_Add_StepTargets
ExternalProject: Convert docs to a bracket comment Use a bracket comment to hold the documentation instead of a block of line comments. This will make further updates easier. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:40:22 +03:00
ExternalProject: Use explicit markup and definition lists in docs Convert ExternalProject module documentation to use explicit markup blocks for each command. Enumerate command options with definition lists instead of a literal block. This will allow more detail to be added later. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:44:00 +03:00
The ``ExternalProject_Add_StepTargets`` function generates custom
targets for the steps listed::
ExternalProject: Convert docs to a bracket comment Use a bracket comment to hold the documentation instead of a block of line comments. This will make further updates easier. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:40:22 +03:00
ExternalProject: Add independent step targets When adding step targets using ExternalProject_Add_StepTargets, the STEP_TARGETS argument or the EP_STEP_TARGETS property, ExternalProject sets all the dependencies for the main project to that target. Due to this, the update target cannot be used without downloading and building all the dependencies. In order to be able to add step targets that do not depend on other external projects, this patch adds: * An optional "NO_DEPENDS" argument to the ExternalProject_Add_StepTargets function. If this argument is set, then no dependencies are set for the target (file dependencies will still be set). * A new argument INDEPENDENT_STEP_TARGETS to the ExternalProject_Add function and a new directory property EP_INDEPENDENT_STEP_TARGETS that behave like STEP_TARGETS and EP_STEP_TARGETS, but cause the ExternalProject_Add_StepTargets to be called with the NO_DEPENDS argument.
2014-11-03 18:14:35 +03:00
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
ExternalProject: Convert docs to a bracket comment Use a bracket comment to hold the documentation instead of a block of line comments. This will make further updates easier. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:40:22 +03:00
individual ``ExternalProject_Add`` calls, or implicitly to all
ExternalProject: Add independent step targets When adding step targets using ExternalProject_Add_StepTargets, the STEP_TARGETS argument or the EP_STEP_TARGETS property, ExternalProject sets all the dependencies for the main project to that target. Due to this, the update target cannot be used without downloading and building all the dependencies. In order to be able to add step targets that do not depend on other external projects, this patch adds: * An optional "NO_DEPENDS" argument to the ExternalProject_Add_StepTargets function. If this argument is set, then no dependencies are set for the target (file dependencies will still be set). * A new argument INDEPENDENT_STEP_TARGETS to the ExternalProject_Add function and a new directory property EP_INDEPENDENT_STEP_TARGETS that behave like STEP_TARGETS and EP_STEP_TARGETS, but cause the ExternalProject_Add_StepTargets to be called with the NO_DEPENDS argument.
2014-11-03 18:14:35 +03:00
``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.
ExternalProject: Convert docs to a bracket comment Use a bracket comment to hold the documentation instead of a block of line comments. This will make further updates easier. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:40:22 +03:00
ExternalProject: Add independent step targets When adding step targets using ExternalProject_Add_StepTargets, the STEP_TARGETS argument or the EP_STEP_TARGETS property, ExternalProject sets all the dependencies for the main project to that target. Due to this, the update target cannot be used without downloading and building all the dependencies. In order to be able to add step targets that do not depend on other external projects, this patch adds: * An optional "NO_DEPENDS" argument to the ExternalProject_Add_StepTargets function. If this argument is set, then no dependencies are set for the target (file dependencies will still be set). * A new argument INDEPENDENT_STEP_TARGETS to the ExternalProject_Add function and a new directory property EP_INDEPENDENT_STEP_TARGETS that behave like STEP_TARGETS and EP_STEP_TARGETS, but cause the ExternalProject_Add_StepTargets to be called with the NO_DEPENDS argument.
2014-11-03 18:14:35 +03:00
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``.
ExternalProject: Convert docs to a bracket comment Use a bracket comment to hold the documentation instead of a block of line comments. This will make further updates easier. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:40:22 +03:00
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)
ExternalProject: Add ExternalProject_Add_StepDependencies function The ExternalProject_Add_StepDependencies function add some dependencies for some external project step. The syntax is: ExternalProject_Add_Step_Dependencies(<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 add_dependencies() when adding a dependency for some of the step targets generated by ExternalProject. See also: http://thread.gmane.org/gmane.comp.programming.tools.cmake.devel/8680/focus=8926
2014-11-03 18:14:49 +03:00
.. 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``.
ExternalProject: Convert docs to a bracket comment Use a bracket comment to hold the documentation instead of a block of line comments. This will make further updates easier. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:40:22 +03:00
#]=======================================================================]
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
Convert CMake non-find modules to BSD License This adds copyright/license notification blocks CMake's non-find modules. Most of the modules had no notices at all. Some had notices referring to the BSD license already. This commit normalizes existing notices and adds missing notices.
2009-09-28 19:46:51 +04:00
#=============================================================================
ExternalProject: Format module documentation Manually revise the .rst format of the documentation. Use inline literal quotes appropriately in paragraph text. Move the :: literal block openers to the end of the preceding paragraphs. Convert the command signature documentation and examples to cmake code-block directives.
2013-11-19 18:27:08 +04:00
# Copyright 2008-2013 Kitware, Inc.
Convert CMake non-find modules to BSD License This adds copyright/license notification blocks CMake's non-find modules. Most of the modules had no notices at all. Some had notices referring to the BSD license already. This commit normalizes existing notices and adds missing notices.
2009-09-28 19:46:51 +04:00
#
# 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.
#=============================================================================
Modules: Fix spelling 'To distributed' -> 'To distribute'
2010-08-07 04:48:47 +04:00
# (To distribute this file outside of CMake, substitute the full
Convert CMake non-find modules to BSD License This adds copyright/license notification blocks CMake's non-find modules. Most of the modules had no notices at all. Some had notices referring to the BSD license already. This commit normalizes existing notices and adds missing notices.
2009-09-28 19:46:51 +04:00
# License text for the above reference.)
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
# Pre-compute a regex to match documented keywords for each command.
Add STEP_TARGETS to ExternalProject module. This commit introduces the ability to add custom targets that correspond to individual ExternalProject steps. The main motivation behind this new feature is to drive sub-project based dashboard steps as external projects with separate targets for update, configure, build and test output. This makes it easy to construct a ctest -S script to drive such a dashboard. With no STEP_TARGETS defined, there are no additional custom targets introduced, to minimize the chatter in the target name space. Clients may define STEP_TARGETS on a per-ExternalProject_Add basis, or at the directory level by setting the EP_STEP_TARGETS directory property.
2010-08-24 01:50:58 +04:00
math(EXPR _ep_documentation_line_count "${CMAKE_CURRENT_LIST_LINE} - 16")
file(STRINGS "${CMAKE_CURRENT_LIST_FILE}" lines
LIMIT_COUNT ${_ep_documentation_line_count}
ExternalProject: Use explicit markup and definition lists in docs Convert ExternalProject module documentation to use explicit markup blocks for each command. Enumerate command options with definition lists instead of a literal block. This will allow more detail to be added later. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:44:00 +03:00
REGEX "^\\.\\. command:: [A-Za-z0-9_]+|^ ``[A-Z0-9_]+ .*``$")
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
foreach(line IN LISTS lines)
ExternalProject: Use explicit markup and definition lists in docs Convert ExternalProject module documentation to use explicit markup blocks for each command. Enumerate command options with definition lists instead of a literal block. This will allow more detail to be added later. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:44:00 +03:00
if("${line}" MATCHES "^\\.\\. command:: ([A-Za-z0-9_]+)")
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
if(_ep_func)
set(_ep_keywords_${_ep_func} "${_ep_keywords_${_ep_func}})$")
endif()
Clean up usage of if(... MATCHES regex) followed string(REGEX REPLACE regex) The matches have already been calculated and can simply be taken from CMAKE_MATCH_n variables. This avoids multiple compilations of the same or very similar regular expressions.
2014-04-06 23:30:00 +04:00
set(_ep_func "${CMAKE_MATCH_1}")
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
#message("function [${_ep_func}]")
set(_ep_keywords_${_ep_func} "^(")
set(_ep_keyword_sep)
ExternalProject: Use explicit markup and definition lists in docs Convert ExternalProject module documentation to use explicit markup blocks for each command. Enumerate command options with definition lists instead of a literal block. This will allow more detail to be added later. Also fix the logic that parses options out of the documentation to be aware of the new layout.
2014-10-28 19:44:00 +03:00
elseif("${line}" MATCHES "^ ``([A-Z0-9_]+) .*``$")
set(_ep_key "${CMAKE_MATCH_1}")
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
#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()
ExternalProject: Generalize URL_MD5 option to URL_HASH Add support for SHA algorithms.
2012-09-11 18:53:17 +04:00
# 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]+)$")
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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
ExternalProject: Remove 'unknown keyword' warning (#11034) The intent was to warn about misspelled keyword arguments, but the effect was to warn about valid argument values far too often. Let's stop annoying and confusing people.
2010-07-28 16:16:08 +04:00
# upper-case letter followed by at least two more upper-case letters,
# numbers or underscores to be keywords.
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
set(key)
BUG: Allow arbitrary text in values for some keywords. (And avoid warning that the arbitrary text is an unknown keyword.)
2009-07-03 01:38:30 +04:00
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
foreach(arg IN LISTS args)
BUG: Allow arbitrary text in values for some keywords. (And avoid warning that the arbitrary text is an unknown keyword.)
2009-07-03 01:38:30 +04:00
set(is_value 1)
Improve FILE(DOWNLOAD) and ExternalProject. Improve FILE(DOWNLOAD ...): - Add percent complete progress output to the FILE DOWNLOAD command. This progress output is off by default to preserve existing behavior. To turn it on, pass SHOW_PROGRESS as an argument. - Add EXPECTED_MD5 argument. Verify that the downloaded file has the expected md5 sum after download is complete. - Add documentation for SHOW_PROGRESS and EXPECTED_MD5. When the destination file exists already and has the expected md5 sum, then do not bother re-downloading the file. ("Short circuit" return.) Also, add a test that checks for the status output indicating that the short circuit behavior is actually occurring. Use a binary file for the test so that the md5 sum is guaranteed to be the same on all platforms regardless of "shifting text file line ending" issues. Improve ExternalProject: - Add argument URL_MD5. - Add verify step that compares md5 sum of .tar.gz file before extracting it. - Add md5 check to download step, too, to prevent unnecessary downloads. - Emit a warning message when a file is not verified. Indicate that the file may be corrupt or that no checksum was specified.
2010-05-27 20:21:56 +04:00
if(arg MATCHES "^[A-Z][A-Z0-9_][A-Z0-9_]+$" AND
ExternalProject: Fix CMP0054 warning in _ep_parse_arguments Fix the CMP0054 warning: CMake Warning (dev) at .../Modules/ExternalProject.cmake:242 (if): Policy CMP0054 is not set: Only interpret if() arguments as variables or keywords when unquoted. Run "cmake --help-policy CMP0054" for policy details. Use the cmake_policy command to set the policy and suppress this warning. Quoted keywords like "COMMAND" will no longer be interpreted as keywords when the policy is set to NEW. Since the policy is not set the OLD behavior will be used. Call Stack (most recent call first): .../Modules/ExternalProject.cmake:1938 (_ep_parse_arguments) CMakeLists.txt:5 (ExternalProject_Add) by avoiding a reference to "${key}" or "COMMAND" in quotes.
2014-09-15 22:49:25 +04:00
NOT (("x${arg}x" STREQUAL "x${key}x") AND ("x${key}x" STREQUAL "xCOMMANDx")) AND
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
NOT arg MATCHES "^(TRUE|FALSE)$")
BUG: Allow arbitrary text in values for some keywords. (And avoid warning that the arbitrary text is an unknown keyword.)
2009-07-03 01:38:30 +04:00
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}")
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
else()
BUG: Allow arbitrary text in values for some keywords. (And avoid warning that the arbitrary text is an unknown keyword.)
2009-07-03 01:38:30 +04:00
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()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
endif()
BUG: Allow arbitrary text in values for some keywords. (And avoid warning that the arbitrary text is an unknown keyword.)
2009-07-03 01:38:30 +04:00
else()
# Missing Keyword
message(AUTHOR_WARNING "value '${arg}' with no previous keyword in ${f}")
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
endif()
else()
BUG: Allow arbitrary text in values for some keywords. (And avoid warning that the arbitrary text is an unknown keyword.)
2009-07-03 01:38:30 +04:00
set(key "${arg}")
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
endif()
endforeach()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
define_property(DIRECTORY PROPERTY "EP_BASE" INHERITED
BRIEF_DOCS "Base directory for External Project storage."
FULL_DOCS
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
"See documentation of the ExternalProject_Add() function in the "
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
"ExternalProject module."
)
define_property(DIRECTORY PROPERTY "EP_PREFIX" INHERITED
BRIEF_DOCS "Top prefix for External Project storage."
FULL_DOCS
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
"See documentation of the ExternalProject_Add() function in the "
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
"ExternalProject module."
)
Add STEP_TARGETS to ExternalProject module. This commit introduces the ability to add custom targets that correspond to individual ExternalProject steps. The main motivation behind this new feature is to drive sub-project based dashboard steps as external projects with separate targets for update, configure, build and test output. This makes it easy to construct a ctest -S script to drive such a dashboard. With no STEP_TARGETS defined, there are no additional custom targets introduced, to minimize the chatter in the target name space. Clients may define STEP_TARGETS on a per-ExternalProject_Add basis, or at the directory level by setting the EP_STEP_TARGETS directory property.
2010-08-24 01:50:58 +04:00
define_property(DIRECTORY PROPERTY "EP_STEP_TARGETS" INHERITED
BRIEF_DOCS
"List of ExternalProject steps that automatically get corresponding targets"
FULL_DOCS
ExternalProject: Add independent step targets When adding step targets using ExternalProject_Add_StepTargets, the STEP_TARGETS argument or the EP_STEP_TARGETS property, ExternalProject sets all the dependencies for the main project to that target. Due to this, the update target cannot be used without downloading and building all the dependencies. In order to be able to add step targets that do not depend on other external projects, this patch adds: * An optional "NO_DEPENDS" argument to the ExternalProject_Add_StepTargets function. If this argument is set, then no dependencies are set for the target (file dependencies will still be set). * A new argument INDEPENDENT_STEP_TARGETS to the ExternalProject_Add function and a new directory property EP_INDEPENDENT_STEP_TARGETS that behave like STEP_TARGETS and EP_STEP_TARGETS, but cause the ExternalProject_Add_StepTargets to be called with the NO_DEPENDS argument.
2014-11-03 18:14:35 +03:00
"These targets will be dependent on the main target dependencies"
Add STEP_TARGETS to ExternalProject module. This commit introduces the ability to add custom targets that correspond to individual ExternalProject steps. The main motivation behind this new feature is to drive sub-project based dashboard steps as external projects with separate targets for update, configure, build and test output. This makes it easy to construct a ctest -S script to drive such a dashboard. With no STEP_TARGETS defined, there are no additional custom targets introduced, to minimize the chatter in the target name space. Clients may define STEP_TARGETS on a per-ExternalProject_Add basis, or at the directory level by setting the EP_STEP_TARGETS directory property.
2010-08-24 01:50:58 +04:00
"See documentation of the ExternalProject_Add_StepTargets() function in the "
"ExternalProject module."
)
ExternalProject: Add independent step targets When adding step targets using ExternalProject_Add_StepTargets, the STEP_TARGETS argument or the EP_STEP_TARGETS property, ExternalProject sets all the dependencies for the main project to that target. Due to this, the update target cannot be used without downloading and building all the dependencies. In order to be able to add step targets that do not depend on other external projects, this patch adds: * An optional "NO_DEPENDS" argument to the ExternalProject_Add_StepTargets function. If this argument is set, then no dependencies are set for the target (file dependencies will still be set). * A new argument INDEPENDENT_STEP_TARGETS to the ExternalProject_Add function and a new directory property EP_INDEPENDENT_STEP_TARGETS that behave like STEP_TARGETS and EP_STEP_TARGETS, but cause the ExternalProject_Add_StepTargets to be called with the NO_DEPENDS argument.
2014-11-03 18:14:35 +03:00
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."
)
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
ExternalProject: Add UPDATE_DISCONNECTED option 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.
2014-11-05 02:31:40 +03:00
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."
)
ExternalProject: Add option GIT_SUBMODULES This option allows to filter the submodules that are checked out. Add a simple testcase for GIT_SUBMODULES option passing an empty list.
2014-01-09 18:07:10 +04:00
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)
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
file(WRITE ${script_filename}
"if(\"${git_tag}\" STREQUAL \"\")
message(FATAL_ERROR \"Tag for git checkout should not be empty.\")
endif()
ExternalProject: Avoid repeated git clone operations (#12564) By tracking a stamp file within the git clone script itself. Avoids a 2nd git clone operation after switching from Debug to Release builds in Visual Studio, or vice-versa.
2012-04-28 19:40:12 +04:00
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()
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
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()
ExternalProject: Retry on a failed git clone Git sometimes fails to clone repositories due to network outage or server load. Try 3 times before giving up.
2013-03-21 01:54:49 +04:00
# 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()
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
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(
ExternalProject: Initialize only selected git submodules (#15590) Honor the GIT_SUBMODULES option added by commit v3.0.0-rc1~92^2 (ExternalProject: Add option GIT_SUBMODULES, 2014-01-09) during the 'git submodule init' step to avoid initalizing all modules since we are only going to update the specified subset anyway. This will be useful for project repositories that have many submodules (e.g. https://github.com/boostorg/boost). Reviewed-by: Daniele E. Domenichelli <daniele.domenichelli@iit.it>
2015-05-28 17:22:28 +03:00
COMMAND \"${git_EXECUTABLE}\" submodule init ${git_submodules}
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
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(
ExternalProject: Add option GIT_SUBMODULES This option allows to filter the submodules that are checked out. Add a simple testcase for GIT_SUBMODULES option passing an empty list.
2014-01-09 18:07:10 +04:00
COMMAND \"${git_EXECUTABLE}\" submodule update --recursive ${git_submodules}
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
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()
ExternalProject: Avoid repeated git clone operations (#12564) By tracking a stamp file within the git clone script itself. Avoids a 2nd git clone operation after switching from Debug to Release builds in Visual Studio, or vice-versa.
2012-04-28 19:40:12 +04:00
# 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()
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
"
)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
ExternalProject: Add Mercurial (hg) repository support Add options HG_REPOSITORY and HG_TAG to specify an external project hosted in a Mercurial repository. Teach ExternalProject to clone the repository and update from it. Extend the ExternalProject test to try a Mercurial repository when hg is available.
2012-08-15 18:09:43 +04:00
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()
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
ExternalProject: Add option GIT_SUBMODULES This option allows to filter the submodules that are checked out. Add a simple testcase for GIT_SUBMODULES option passing an empty list.
2014-01-09 18:07:10 +04:00
function(_ep_write_gitupdate_script script_filename git_EXECUTABLE git_tag git_submodules git_repository work_dir)
ExternalProject: Only run 'git fetch' when required. In the current default update step for Git under the ExternalProject_Add command, a 'git fetch' is always performed, followed by a 'git checkout' and 'git submodule update --recursive'. However, a 'git fetch' can be time consuming and requires a network connection. To save time, we look at the current checked out hash, and only perform the fetch if required. This is performed in a CMake script so we can handle the conditional logic in a cross platform manner.
2012-06-09 02:29:34 +04:00
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
ExternalProject: Strip trailing space from git hash
2013-11-18 15:03:58 +04:00
OUTPUT_STRIP_TRAILING_WHITESPACE
ExternalProject: Only run 'git fetch' when required. In the current default update step for Git under the ExternalProject_Add command, a 'git fetch' is always performed, followed by a 'git checkout' and 'git submodule update --recursive'. However, a 'git fetch' can be time consuming and requires a network connection. To save time, we look at the current checked out hash, and only perform the fetch if required. This is performed in a CMake script so we can handle the conditional logic in a cross platform manner.
2012-06-09 02:29:34 +04:00
)
if(error_code)
message(FATAL_ERROR \"Failed to get the hash for HEAD\")
endif()
ExternalProject: Always do a git fetch for a remote ref. Remote git refs always require a git fetch, because the remote may move around where the ref points.
2012-07-27 21:38:01 +04:00
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()
ExternalProject: Improve handling of git remote branches ExternalProject handles git remote branches by commit hash. Due to this, the git repository ends in detached states, and local commits are discarded. Use "git rebase" for remote branches instead of "git checkout". If there are uncommitted changes, use "git stash save/pop" to save changes and restore them after the rebase. If any of these operations fails, try to restore the original status and exit with a fatal error, asking the user to resolve the conflicts manually. This also makes the behaviour of ExternalProject using git more similar to the svn version, and probably more likely to what the user expects by setting GIT_TAG to a branch.
2013-11-18 14:36:18 +04:00
# 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()
ExternalProject: Only run 'git fetch' when required. In the current default update step for Git under the ExternalProject_Add command, a 'git fetch' is always performed, followed by a 'git checkout' and 'git submodule update --recursive'. However, a 'git fetch' can be time consuming and requires a network connection. To save time, we look at the current checked out hash, and only perform the fetch if required. This is performed in a CMake script so we can handle the conditional logic in a cross platform manner.
2012-06-09 02:29:34 +04:00
# 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
ExternalProject: Strip trailing space from git hash
2013-11-18 15:03:58 +04:00
OUTPUT_STRIP_TRAILING_WHITESPACE
ExternalProject: Only run 'git fetch' when required. In the current default update step for Git under the ExternalProject_Add command, a 'git fetch' is always performed, followed by a 'git checkout' and 'git submodule update --recursive'. However, a 'git fetch' can be time consuming and requires a network connection. To save time, we look at the current checked out hash, and only perform the fetch if required. This is performed in a CMake script so we can handle the conditional logic in a cross platform manner.
2012-06-09 02:29:34 +04:00
)
# Is the hash checkout out that we want?
ExternalProject: Always do a git fetch for a remote ref. Remote git refs always require a git fetch, because the remote may move around where the ref points.
2012-07-27 21:38:01 +04:00
if(error_code OR is_remote_ref OR NOT (\"\${tag_sha}\" STREQUAL \"\${head_sha}\"))
ExternalProject: Only run 'git fetch' when required. In the current default update step for Git under the ExternalProject_Add command, a 'git fetch' is always performed, followed by a 'git checkout' and 'git submodule update --recursive'. However, a 'git fetch' can be time consuming and requires a network connection. To save time, we look at the current checked out hash, and only perform the fetch if required. This is performed in a CMake script so we can handle the conditional logic in a cross platform manner.
2012-06-09 02:29:34 +04:00
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()
ExternalProject: Improve handling of git remote branches ExternalProject handles git remote branches by commit hash. Due to this, the git repository ends in detached states, and local commits are discarded. Use "git rebase" for remote branches instead of "git checkout". If there are uncommitted changes, use "git stash save/pop" to save changes and restore them after the rebase. If any of these operations fails, try to restore the original status and exit with a fatal error, asking the user to resolve the conflicts manually. This also makes the behaviour of ExternalProject using git more similar to the svn version, and probably more likely to what the user expects by setting GIT_TAG to a branch.
2013-11-18 14:36:18 +04:00
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()
ExternalProject: Only run 'git fetch' when required. In the current default update step for Git under the ExternalProject_Add command, a 'git fetch' is always performed, followed by a 'git checkout' and 'git submodule update --recursive'. However, a 'git fetch' can be time consuming and requires a network connection. To save time, we look at the current checked out hash, and only perform the fetch if required. This is performed in a CMake script so we can handle the conditional logic in a cross platform manner.
2012-06-09 02:29:34 +04:00
endif()
execute_process(
ExternalProject: Add option GIT_SUBMODULES This option allows to filter the submodules that are checked out. Add a simple testcase for GIT_SUBMODULES option passing an empty list.
2014-01-09 18:07:10 +04:00
COMMAND \"${git_EXECUTABLE}\" submodule update --recursive ${git_submodules}
ExternalProject: Only run 'git fetch' when required. In the current default update step for Git under the ExternalProject_Add command, a 'git fetch' is always performed, followed by a 'git checkout' and 'git submodule update --recursive'. However, a 'git fetch' can be time consuming and requires a network connection. To save time, we look at the current checked out hash, and only perform the fetch if required. This is performed in a CMake script so we can handle the conditional logic in a cross platform manner.
2012-06-09 02:29:34 +04:00
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)
ExternalProject: Add option to disable download progress (#14807) Add a DOWNLOAD_NO_PROGRESS option to disable progress reports while downloading source tarballs.
2014-03-17 19:24:20 +04:00
function(_ep_write_downloadfile_script script_filename remote local timeout no_progress hash tls_verify tls_cainfo)
Fix issue #9764 - add TIMEOUT arg to ExternalProject_Add so that callers have explicit control over the amount of time they are willing to wait for a download step. Default to no timeout, which means just run download for however long it takes.
2009-12-11 23:04:55 +03:00
if(timeout)
set(timeout_args TIMEOUT ${timeout})
set(timeout_msg "${timeout} seconds")
else()
set(timeout_args "# no TIMEOUT")
set(timeout_msg "none")
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
endif()
ExternalProject: Add option to disable download progress (#14807) Add a DOWNLOAD_NO_PROGRESS option to disable progress reports while downloading source tarballs.
2014-03-17 19:24:20 +04:00
if(no_progress)
set(show_progress "")
else()
set(show_progress "SHOW_PROGRESS")
endif()
ExternalProject: Restore logic to not download already-existing file The change in commit v3.1.0-rc1~85^2 (ExternalProject: Fix download retry logic, 2014-09-13) dropped the file(DOWNLOAD) EXPECTED_HASH argument. This prevents file(DOWNLOAD) from skipping the download if the output file already exists with the proper hash. Restore this check with explicit code in the download script. Reported-by: Ruslan Baratov <ruslan_baratov@yahoo.com>
2014-11-10 19:09:12 +03:00
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()
Add SSL_VERIFYPEER and CAINFO file options to ExternalProject_Add. This commit adds the ability to turn on and off ssl certificate authority checking. It also adds the ability to specify a certificate authority information file. This can be done by setting global cmake variables CMAKE_CURLOPT_CAINFO_FILE and or CMAKE_CURLOPT_SSL_VERIFYPEER in the project calling ExternalProject_Add, or by passing those options to individual ExternalProject_Add calls.
2012-09-13 02:31:52 +04:00
# check for curl globals in the project
Rename SSL terminology to TLS TLS has superseded SSL so rename the recently added file(DOWNLOAD) and ExternalProject options using the newer terminology. Drop "CURLOPT" from names because curl is an implementation detail.
2012-09-14 23:40:09 +04:00
if(DEFINED CMAKE_TLS_VERIFY)
set(tls_verify "set(CMAKE_TLS_VERIFY ${CMAKE_TLS_VERIFY})")
Add SSL_VERIFYPEER and CAINFO file options to ExternalProject_Add. This commit adds the ability to turn on and off ssl certificate authority checking. It also adds the ability to specify a certificate authority information file. This can be done by setting global cmake variables CMAKE_CURLOPT_CAINFO_FILE and or CMAKE_CURLOPT_SSL_VERIFYPEER in the project calling ExternalProject_Add, or by passing those options to individual ExternalProject_Add calls.
2012-09-13 02:31:52 +04:00
endif()
Rename SSL terminology to TLS TLS has superseded SSL so rename the recently added file(DOWNLOAD) and ExternalProject options using the newer terminology. Drop "CURLOPT" from names because curl is an implementation detail.
2012-09-14 23:40:09 +04:00
if(DEFINED CMAKE_TLS_CAINFO)
set(tls_cainfo "set(CMAKE_TLS_CAINFO \"${CMAKE_TLS_CAINFO}\")")
Add SSL_VERIFYPEER and CAINFO file options to ExternalProject_Add. This commit adds the ability to turn on and off ssl certificate authority checking. It also adds the ability to specify a certificate authority information file. This can be done by setting global cmake variables CMAKE_CURLOPT_CAINFO_FILE and or CMAKE_CURLOPT_SSL_VERIFYPEER in the project calling ExternalProject_Add, or by passing those options to individual ExternalProject_Add calls.
2012-09-13 02:31:52 +04:00
endif()
# now check for curl locals so that the local values
# will override the globals
Rename SSL terminology to TLS TLS has superseded SSL so rename the recently added file(DOWNLOAD) and ExternalProject options using the newer terminology. Drop "CURLOPT" from names because curl is an implementation detail.
2012-09-14 23:40:09 +04:00
# 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})")
Add SSL_VERIFYPEER and CAINFO file options to ExternalProject_Add. This commit adds the ability to turn on and off ssl certificate authority checking. It also adds the ability to specify a certificate authority information file. This can be done by setting global cmake variables CMAKE_CURLOPT_CAINFO_FILE and or CMAKE_CURLOPT_SSL_VERIFYPEER in the project calling ExternalProject_Add, or by passing those options to individual ExternalProject_Add calls.
2012-09-13 02:31:52 +04:00
endif()
Rename SSL terminology to TLS TLS has superseded SSL so rename the recently added file(DOWNLOAD) and ExternalProject options using the newer terminology. Drop "CURLOPT" from names because curl is an implementation detail.
2012-09-14 23:40:09 +04:00
# 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}\")")
Add SSL_VERIFYPEER and CAINFO file options to ExternalProject_Add. This commit adds the ability to turn on and off ssl certificate authority checking. It also adds the ability to specify a certificate authority information file. This can be done by setting global cmake variables CMAKE_CURLOPT_CAINFO_FILE and or CMAKE_CURLOPT_SSL_VERIFYPEER in the project calling ExternalProject_Add, or by passing those options to individual ExternalProject_Add calls.
2012-09-13 02:31:52 +04:00
endif()
Improve FILE(DOWNLOAD) and ExternalProject. Improve FILE(DOWNLOAD ...): - Add percent complete progress output to the FILE DOWNLOAD command. This progress output is off by default to preserve existing behavior. To turn it on, pass SHOW_PROGRESS as an argument. - Add EXPECTED_MD5 argument. Verify that the downloaded file has the expected md5 sum after download is complete. - Add documentation for SHOW_PROGRESS and EXPECTED_MD5. When the destination file exists already and has the expected md5 sum, then do not bother re-downloading the file. ("Short circuit" return.) Also, add a test that checks for the status output indicating that the short circuit behavior is actually occurring. Use a binary file for the test so that the md5 sum is guaranteed to be the same on all platforms regardless of "shifting text file line ending" issues. Improve ExternalProject: - Add argument URL_MD5. - Add verify step that compares md5 sum of .tar.gz file before extracting it. - Add md5 check to download step, too, to prevent unnecessary downloads. - Emit a warning message when a file is not verified. Indicate that the file may be corrupt or that no checksum was specified.
2010-05-27 20:21:56 +04:00
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
file(WRITE ${script_filename}
ExternalProject: Restore logic to not download already-existing file The change in commit v3.1.0-rc1~85^2 (ExternalProject: Fix download retry logic, 2014-09-13) dropped the file(DOWNLOAD) EXPECTED_HASH argument. This prevents file(DOWNLOAD) from skipping the download if the output file already exists with the proper hash. Restore this check with explicit code in the download script. Reported-by: Ruslan Baratov <ruslan_baratov@yahoo.com>
2014-11-10 19:09:12 +03:00
"${hash_check}message(STATUS \"downloading...
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
src='${remote}'
Fix issue #9764 - add TIMEOUT arg to ExternalProject_Add so that callers have explicit control over the amount of time they are willing to wait for a download step. Default to no timeout, which means just run download for however long it takes.
2009-12-11 23:04:55 +03:00
dst='${local}'
timeout='${timeout_msg}'\")
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
Rename SSL terminology to TLS TLS has superseded SSL so rename the recently added file(DOWNLOAD) and ExternalProject options using the newer terminology. Drop "CURLOPT" from names because curl is an implementation detail.
2012-09-14 23:40:09 +04:00
${tls_verify}
${tls_cainfo}
Add SSL_VERIFYPEER and CAINFO file options to ExternalProject_Add. This commit adds the ability to turn on and off ssl certificate authority checking. It also adds the ability to specify a certificate authority information file. This can be done by setting global cmake variables CMAKE_CURLOPT_CAINFO_FILE and or CMAKE_CURLOPT_SSL_VERIFYPEER in the project calling ExternalProject_Add, or by passing those options to individual ExternalProject_Add calls.
2012-09-13 02:31:52 +04:00
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
file(DOWNLOAD
\"${remote}\"
\"${local}\"
ExternalProject: Add option to disable download progress (#14807) Add a DOWNLOAD_NO_PROGRESS option to disable progress reports while downloading source tarballs.
2014-03-17 19:24:20 +04:00
${show_progress}
Fix issue #9764 - add TIMEOUT arg to ExternalProject_Add so that callers have explicit control over the amount of time they are willing to wait for a download step. Default to no timeout, which means just run download for however long it takes.
2009-12-11 23:04:55 +03:00
${timeout_args}
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
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\")
"
)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
ExternalProject: Reattempt download when verification fails. When downloading an URL with ExternalProject, reattempt the download three times if the file hash verification fails. The re-attempt is limited to non-local URL's. The same download CMake script is re-used after removing any file that resulted from the previous download attempt. Up to three re-attempts are performed.
2014-01-16 01:31:23 +04:00
function(_ep_write_verifyfile_script script_filename local hash retries download_script)
ExternalProject: Generalize URL_MD5 option to URL_HASH Add support for SHA algorithms.
2012-09-11 18:53:17 +04:00
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}\")
ExternalProject: Reattempt download when verification fails. When downloading an URL with ExternalProject, reattempt the download three times if the file hash verification fails. The re-attempt is limited to non-local URL's. The same download CMake script is re-used after removing any file that resulted from the previous download attempt. Up to three re-attempts are performed.
2014-01-16 01:31:23 +04:00
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}\")
ExternalProject: Fix path to cmake in verify script In commit v3.0.0-rc1~103^2~3 (ExternalProject: Reattempt download when verification fails, 2014-01-15) a reference to ${CMAKE_COMMAND} was added to generate a reference to the CMake command in a cmake script. Escape the '$' so that the literal variable reference appears in the script instead of writing the path to the current cmake. This is necessary when the path to CMake contains spaces or other characters special to CMake syntax.
2014-05-01 00:18:13 +04:00
execute_process(COMMAND \${CMAKE_COMMAND} -P \"${download_script}\")
ExternalProject: Reattempt download when verification fails. When downloading an URL with ExternalProject, reattempt the download three times if the file hash verification fails. The re-attempt is limited to non-local URL's. The same download CMake script is re-used after removing any file that resulted from the previous download attempt. Up to three re-attempts are performed.
2014-01-16 01:31:23 +04:00
endif()
ExternalProject: Avoid infinite loop on file download hash mismatch When the loop was added by commit v3.0.0-rc1~103^2~3 (ExternalProject: Reattempt download when verification fails, 2015-01-15), we forgot to actually increment the loop counter. Add the increment line.
2014-09-08 23:24:17 +04:00
math(EXPR attempt \"\${attempt} + 1\")
ExternalProject: Reattempt download when verification fails. When downloading an URL with ExternalProject, reattempt the download three times if the file hash verification fails. The re-attempt is limited to non-local URL's. The same download CMake script is re-used after removing any file that resulted from the previous download attempt. Up to three re-attempts are performed.
2014-01-16 01:31:23 +04:00
endwhile()
if(\${succeeded})
Improve FILE(DOWNLOAD) and ExternalProject. Improve FILE(DOWNLOAD ...): - Add percent complete progress output to the FILE DOWNLOAD command. This progress output is off by default to preserve existing behavior. To turn it on, pass SHOW_PROGRESS as an argument. - Add EXPECTED_MD5 argument. Verify that the downloaded file has the expected md5 sum after download is complete. - Add documentation for SHOW_PROGRESS and EXPECTED_MD5. When the destination file exists already and has the expected md5 sum, then do not bother re-downloading the file. ("Short circuit" return.) Also, add a test that checks for the status output indicating that the short circuit behavior is actually occurring. Use a binary file for the test so that the md5 sum is guaranteed to be the same on all platforms regardless of "shifting text file line ending" issues. Improve ExternalProject: - Add argument URL_MD5. - Add verify step that compares md5 sum of .tar.gz file before extracting it. - Add md5 check to download step, too, to prevent unnecessary downloads. - Emit a warning message when a file is not verified. Indicate that the file may be corrupt or that no checksum was specified.
2010-05-27 20:21:56 +04:00
message(STATUS \"verifying file... done\")
else()
ExternalProject: Generalize URL_MD5 option to URL_HASH Add support for SHA algorithms.
2012-09-11 18:53:17 +04:00
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}
")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
Improve FILE(DOWNLOAD) and ExternalProject. Improve FILE(DOWNLOAD ...): - Add percent complete progress output to the FILE DOWNLOAD command. This progress output is off by default to preserve existing behavior. To turn it on, pass SHOW_PROGRESS as an argument. - Add EXPECTED_MD5 argument. Verify that the downloaded file has the expected md5 sum after download is complete. - Add documentation for SHOW_PROGRESS and EXPECTED_MD5. When the destination file exists already and has the expected md5 sum, then do not bother re-downloading the file. ("Short circuit" return.) Also, add a test that checks for the status output indicating that the short circuit behavior is actually occurring. Use a binary file for the test so that the md5 sum is guaranteed to be the same on all platforms regardless of "shifting text file line ending" issues. Improve ExternalProject: - Add argument URL_MD5. - Add verify step that compares md5 sum of .tar.gz file before extracting it. - Add md5 check to download step, too, to prevent unnecessary downloads. - Emit a warning message when a file is not verified. Indicate that the file may be corrupt or that no checksum was specified.
2010-05-27 20:21:56 +04:00
Qualify name of extraction location with ExternalProject name. Avoid issues with two external projects trying to extract two separate trees at the same time into the same location. Should fix the sporadically failing ExternalProject test on the dashboards for parallel builds.
2010-06-23 15:04:06 +04:00
function(_ep_write_extractfile_script script_filename name filename directory)
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
set(args "")
ExternalProject: Recognize lzma-compressed files (#13515) Add .7z, .tar.xz, and .txz file extensions. Inspired-by: Joke de Buhr <joke@seiken.de> Inspired-by: David Cole <DLRdave@aol.com>
2014-07-23 23:54:04 +04:00
if(filename MATCHES "(\\.|=)(7z|tar\\.bz2|tar\\.gz|tar\\.xz|tbz2|tgz|txz|zip)$")
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
set(args xfz)
endif()
ExternalProject: Extract file names from more urls Notably, downloads from sourceforge.net and gitweb snapshots.
2011-03-05 00:51:46 +03:00
if(filename MATCHES "(\\.|=)tar$")
Add .zip and .tar.bz2 extraction to ExternalProject. Add archives of these file types and add to the test cases covered in the ExternalProject test. Also add an "Example" directory in the Tests/ExternalProject directory containing the canonical simplest example of ExternalProject usage.
2010-05-31 22:22:24 +04:00
set(args xf)
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
endif()
if(args STREQUAL "")
ExternalProject: Recognize lzma-compressed files (#13515) Add .7z, .tar.xz, and .txz file extensions. Inspired-by: Joke de Buhr <joke@seiken.de> Inspired-by: David Cole <DLRdave@aol.com>
2014-07-23 23:54:04 +04:00
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")
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
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}'\")
Add .zip and .tar.bz2 extraction to ExternalProject. Add archives of these file types and add to the test cases covered in the ExternalProject test. Also add an "Example" directory in the Tests/ExternalProject directory containing the canonical simplest example of ExternalProject usage.
2010-05-31 22:22:24 +04:00
if(NOT EXISTS \"\${filename}\")
message(FATAL_ERROR \"error: file to extract does not exist: '\${filename}'\")
endif()
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
# Prepare a space for extracting:
#
Use RENAME, not COPY, to extract .tar.gz files. Use ABSOLUTE file name for the RENAME operation. (Thanks to Marcus for figuring out that it doesn't work on Linux without the ABSOLUTE bit.)
2010-05-27 01:42:56 +04:00
set(i 1234)
Qualify name of extraction location with ExternalProject name. Avoid issues with two external projects trying to extract two separate trees at the same time into the same location. Should fix the sporadically failing ExternalProject test on the dashboards for parallel builds.
2010-06-23 15:04:06 +04:00
while(EXISTS \"\${directory}/../ex-${name}\${i}\")
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
math(EXPR i \"\${i} + 1\")
endwhile()
Qualify name of extraction location with ExternalProject name. Avoid issues with two external projects trying to extract two separate trees at the same time into the same location. Should fix the sporadically failing ExternalProject test on the dashboards for parallel builds.
2010-06-23 15:04:06 +04:00
set(ut_dir \"\${directory}/../ex-${name}\${i}\")
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
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()
Use RENAME, not COPY, to extract .tar.gz files. Use ABSOLUTE file name for the RENAME operation. (Thanks to Marcus for figuring out that it doesn't work on Linux without the ABSOLUTE bit.)
2010-05-27 01:42:56 +04:00
# Move \"the one\" directory to the final directory:
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
#
Use RENAME, not COPY, to extract .tar.gz files. Use ABSOLUTE file name for the RENAME operation. (Thanks to Marcus for figuring out that it doesn't work on Linux without the ABSOLUTE bit.)
2010-05-27 01:42:56 +04:00
message(STATUS \"extracting... [rename]\")
file(REMOVE_RECURSE \${directory})
get_filename_component(contents \${contents} ABSOLUTE)
file(RENAME \${contents} \${directory})
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
# Clean up:
#
message(STATUS \"extracting... [clean up]\")
file(REMOVE_RECURSE \"\${ut_dir}\")
message(STATUS \"extracting... done\")
"
)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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}")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
else()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
ExternalProject: Replace location tags in CMAKE_CACHE_ARGS When we added CMAKE_CACHE_ARGS, we did not try it with any <SOURCE_DIR> or <INSTALL_DIR> references. This commit fixes that accidental omission.
2011-01-07 16:04:16 +03:00
# 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()
ExternalProject: Add CMAKE_CACHE_DEFAULT_ARGS arguments This argument allows to set default arguments that are written in the initial cache file, but that are not forced, and therefore allows the user to change these values later (CMAKE_ARGS and CMAKE_CACHE_ARGS always overwrite the values). Also add some documentation to explain the differences between these 3 arguments. Extend ExternalProjectLocal test to cover CMAKE_CACHE_DEFAULT_ARGS.
2014-10-28 12:52:16 +03:00
function(_ep_command_line_to_initial_cache var args force)
Added CMAKE_CACHE_ARGS to ExternalProject. On Windows the limit for command line arguments is 8192 characters, and this was limiting longer paths with some of our more nested projects such as Library. Placing the -D arguments into CMAKE_CACHE_ARGS will write out an initial cache file, that will be passed to CMake with a -C argument as the initial cache. By forcing the cache variables we preserve the existing behavior with -D, to change the values of cache variables in our inner projects.
2010-12-11 01:41:41 +03:00
set(script_initial_cache "")
set(regex "^([^:]+):([^=]+)=(.*)$")
Escape file write expansion, and build up lists. Escaped the @var@ in the file writes - this was being expanded at file write and so not causing a reconfigure at the right time. I also took care of build up lists of lists in the variables, especially important for things like MPI_EXTRA_LIBRARY. Added some error checking, and use the tmp_dir for initial cache file.
2010-12-11 04:03:58 +03:00
set(setArg "")
ExternalProject: Add CMAKE_CACHE_DEFAULT_ARGS arguments This argument allows to set default arguments that are written in the initial cache file, but that are not forced, and therefore allows the user to change these values later (CMAKE_ARGS and CMAKE_CACHE_ARGS always overwrite the values). Also add some documentation to explain the differences between these 3 arguments. Extend ExternalProjectLocal test to cover CMAKE_CACHE_DEFAULT_ARGS.
2014-10-28 12:52:16 +03:00
set(forceArg "")
if(force)
set(forceArg "FORCE")
endif()
Added CMAKE_CACHE_ARGS to ExternalProject. On Windows the limit for command line arguments is 8192 characters, and this was limiting longer paths with some of our more nested projects such as Library. Placing the -D arguments into CMAKE_CACHE_ARGS will write out an initial cache file, that will be passed to CMake with a -C argument as the initial cache. By forcing the cache variables we preserve the existing behavior with -D, to change the values of cache variables in our inner projects.
2010-12-11 01:41:41 +03:00
foreach(line ${args})
Clean up usage of if(... MATCHES regex) followed string(REGEX REPLACE regex) The matches have already been calculated and can simply be taken from CMAKE_MATCH_n variables. This avoids multiple compilations of the same or very similar regular expressions.
2014-04-06 23:30:00 +04:00
if("${line}" MATCHES "^-D(.*)")
set(line "${CMAKE_MATCH_1}")
Escape file write expansion, and build up lists. Escaped the @var@ in the file writes - this was being expanded at file write and so not causing a reconfigure at the right time. I also took care of build up lists of lists in the variables, especially important for things like MPI_EXTRA_LIBRARY. Added some error checking, and use the tmp_dir for initial cache file.
2010-12-11 04:03:58 +03:00
if(setArg)
# This is required to build up lists in variables, or complete an entry
ExternalProject: Add CMAKE_CACHE_DEFAULT_ARGS arguments This argument allows to set default arguments that are written in the initial cache file, but that are not forced, and therefore allows the user to change these values later (CMAKE_ARGS and CMAKE_CACHE_ARGS always overwrite the values). Also add some documentation to explain the differences between these 3 arguments. Extend ExternalProjectLocal test to cover CMAKE_CACHE_DEFAULT_ARGS.
2014-10-28 12:52:16 +03:00
set(setArg "${setArg}${accumulator}\" CACHE ${type} \"Initial cache\" ${forceArg})")
Escape file write expansion, and build up lists. Escaped the @var@ in the file writes - this was being expanded at file write and so not causing a reconfigure at the right time. I also took care of build up lists of lists in the variables, especially important for things like MPI_EXTRA_LIBRARY. Added some error checking, and use the tmp_dir for initial cache file.
2010-12-11 04:03:58 +03:00
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}")
Added CMAKE_CACHE_ARGS to ExternalProject. On Windows the limit for command line arguments is 8192 characters, and this was limiting longer paths with some of our more nested projects such as Library. Placing the -D arguments into CMAKE_CACHE_ARGS will write out an initial cache file, that will be passed to CMake with a -C argument as the initial cache. By forcing the cache variables we preserve the existing behavior with -D, to change the values of cache variables in our inner projects.
2010-12-11 01:41:41 +03:00
endif()
endforeach()
Fixed bug where last entry would be lost. The code to build up a list was missing the final entry in an initial cache.
2010-12-13 20:50:38 +03:00
# Catch the final line of the args
if(setArg)
ExternalProject: Add CMAKE_CACHE_DEFAULT_ARGS arguments This argument allows to set default arguments that are written in the initial cache file, but that are not forced, and therefore allows the user to change these values later (CMAKE_ARGS and CMAKE_CACHE_ARGS always overwrite the values). Also add some documentation to explain the differences between these 3 arguments. Extend ExternalProjectLocal test to cover CMAKE_CACHE_DEFAULT_ARGS.
2014-10-28 12:52:16 +03:00
set(setArg "${setArg}${accumulator}\" CACHE ${type} \"Initial cache\" ${forceArg})")
Fixed bug where last entry would be lost. The code to build up a list was missing the final entry in an initial cache.
2010-12-13 20:50:38 +03:00
set(script_initial_cache "${script_initial_cache}\n${setArg}")
endif()
ExternalProject: Add CMAKE_CACHE_DEFAULT_ARGS arguments This argument allows to set default arguments that are written in the initial cache file, but that are not forced, and therefore allows the user to change these values later (CMAKE_ARGS and CMAKE_CACHE_ARGS always overwrite the values). Also add some documentation to explain the differences between these 3 arguments. Extend ExternalProjectLocal test to cover CMAKE_CACHE_DEFAULT_ARGS.
2014-10-28 12:52:16 +03:00
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
ExternalProject: Replace location tags in CMAKE_CACHE_ARGS When we added CMAKE_CACHE_ARGS, we did not try it with any <SOURCE_DIR> or <INSTALL_DIR> references. This commit fixes that accidental omission.
2011-01-07 16:04:16 +03:00
# Replace location tags.
_ep_replace_location_tags(${target_name} script_initial_cache)
Added CMAKE_CACHE_ARGS to ExternalProject. On Windows the limit for command line arguments is 8192 characters, and this was limiting longer paths with some of our more nested projects such as Library. Placing the -D arguments into CMAKE_CACHE_ARGS will write out an initial cache file, that will be passed to CMake with a -C argument as the initial cache. By forcing the cache variables we preserve the existing behavior with -D, to change the values of cache variables in our inner projects.
2010-12-11 01:41:41 +03:00
# Write out the initial cache file to the location specified.
ExternalProject: Allow generator expressions in initial cache options Use file(GENERATE) to write the initial cache file so that we can evaluate generator expressions. Use a per-config initial cache file name in case the content varies by configuration.
2015-04-17 07:42:19 +03:00
file(GENERATE OUTPUT "${script_filename}" CONTENT "${script_initial_cache}")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
Added CMAKE_CACHE_ARGS to ExternalProject. On Windows the limit for command line arguments is 8192 characters, and this was limiting longer paths with some of our more nested projects such as Library. Placing the -D arguments into CMAKE_CACHE_ARGS will write out an initial cache file, that will be passed to CMake with a -C argument as the initial cache. By forcing the cache variables we preserve the existing behavior with -D, to change the values of cache variables in our inner projects.
2010-12-11 01:41:41 +03:00
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
function(ExternalProject_Get_Property name)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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)
ExternalProject: Use $(MAKE) whenever possible. ExternalProject_Add calls that did not explicitly request a CMAKE_GENERATOR would not get recursive parallel make behavior. This commit fixes that issue.
2010-07-23 21:51:37 +04:00
if("${CMAKE_GENERATOR}" MATCHES "Make" AND
Fixed parallel build for generators with EXTRA. Fixed parallel build for projects using generators that have the CMAKE_EXTRA_GENERATOR as well as CMAKE_GENERATOR. Thanks to Bill Hoffman for helping me to track this one down, I missed parallel builds.
2010-10-22 19:16:21 +04:00
("${cmake_generator}" MATCHES "Make" OR NOT cmake_generator))
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
# The project uses the same Makefile generator. Use recursive make.
set(cmd "$(MAKE)")
if(step STREQUAL "INSTALL")
set(args install)
endif()
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
if(step STREQUAL "TEST")
set(args test)
endif()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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()
ExternalProject: fix the build command for generator overrides The `binary_dir` variable is never set, so this is invalid. Instead, use "." which all the other build commands use anyways. Also only set the --config option if it is meaningful.
2015-03-27 01:12:04 +03:00
set(args --build ".")
if (CMAKE_CFG_INTDIR AND NOT CMAKE_CFG_INTDIR STREQUAL ".")
list(APPEND args --config "${CMAKE_CFG_INTDIR}")
endif ()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
if(step STREQUAL "INSTALL")
list(APPEND args --target install)
endif()
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
# But for "TEST" drive the project with corresponding "ctest".
if(step STREQUAL "TEST")
string(REGEX REPLACE "^(.*/)cmake([^/]*)$" "\\1ctest\\2" cmd "${cmd}")
set(args "")
endif()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
endif()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
else()
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
# Non-CMake project. Guess "make" and "make install" and "make test".
ExternalProject: Fix 'make' builds with Ninja (#13159) Fix the build command when Ninja is the CMake Generator, but the external project is created for a project that does not use CMake but does use "make".
2012-05-21 22:49:00 +04:00
if("${CMAKE_GENERATOR}" MATCHES "Makefiles")
# Try to get the parallel arguments
set(cmd "$(MAKE)")
else()
set(cmd "make")
endif()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
if(step STREQUAL "INSTALL")
set(args install)
endif()
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
if(step STREQUAL "TEST")
set(args test)
endif()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
function(_ep_write_log_script name step cmd_var)
ExternalProject_Get_Property(${name} stamp_dir)
set(command "${${cmd_var}}")
set(make "")
ExternalProject: Fix $(MAKE) with cygpath on Windows In non-cygwin builds using Cygwin's make tool, use cygpath to transform the value of $(MAKE) to something Windows understands.
2010-08-02 20:02:15 +04:00
set(code_cygpath_make "")
ExternalProject: avoid CMP0054 warnings Found where ${command} is "make" which is a local variable.
2014-12-13 02:30:00 +03:00
if(command MATCHES "^\\$\\(MAKE\\)")
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
# 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)")
ExternalProject: Fix $(MAKE) with cygpath on Windows In non-cygwin builds using Cygwin's make tool, use cygpath to transform the value of $(MAKE) to something Windows understands.
2010-08-02 20:02:15 +04:00
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()
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
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.
ExternalProject: Fix log when the first arg of commands is "COMMAND" (#15567)
2015-05-20 16:14:17 +03:00
if(command MATCHES "(^|;)COMMAND;")
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
set(code_execute_process "
ExternalProject: Fix $(MAKE) with cygpath on Windows In non-cygwin builds using Cygwin's make tool, use cygpath to transform the value of $(MAKE) to something Windows understands.
2010-08-02 20:02:15 +04:00
${code_cygpath_make}
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
execute_process(COMMAND \${command} RESULT_VARIABLE result)
if(result)
set(msg \"Command failed (\${result}):\\n\")
foreach(arg IN LISTS command)
set(msg \"\${msg} '\${arg}'\")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endforeach()
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
message(FATAL_ERROR \"\${msg}\")
endif()
")
set(code "")
set(cmd "")
set(sep "")
foreach(arg IN LISTS command)
if("x${arg}" STREQUAL "xCOMMAND")
ExternalProject: Fix log when the first arg of commands is "COMMAND" (#15567)
2015-05-20 16:14:17 +03:00
if(NOT "x${cmd}" STREQUAL "x")
set(code "${code}set(command \"${cmd}\")${code_execute_process}")
endif()
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
set(cmd "")
set(sep "")
else()
set(cmd "${cmd}${sep}${arg}")
set(sep ";")
endif()
endforeach()
VS: Avoid leaking child process output back to IDE (#14266) The VS IDE sets the environment variable VS_UNICODE_OUTPUT when executing build rules in order to tell MS tools to report output through a back door instead of through stdout/stderr. Unset this variable so that CMake can capture or properly redirect all output from processes it runs even when running inside a VS IDE build environment. This generalizes the special cases fixed by commit 80d045b0 (When GetPrerequisites.cmake runs dumpbin while running inside the VS IDE..., 2008-05-01) and commit 44aff73d (ExternalProject: Avoid bleed-through output when logging, 2011-01-06), so drop special handling of VS_UNICODE_OUTPUT in those instances.
2013-07-10 19:50:49 +04:00
set(code "${code}set(command \"${cmd}\")${code_execute_process}")
ExternalProject: Allow generator expressions with LOG_* options (#15287) Use file(GENERATE) to write the logging wrapper scripts to evaluate generator expressions. Use a per-config script names in case the content varies by configuration.
2015-04-21 09:28:21 +03:00
file(GENERATE OUTPUT "${stamp_dir}/${name}-${step}-$<CONFIG>-impl.cmake" CONTENT "${code}")
set(command ${CMAKE_COMMAND} "-Dmake=\${make}" "-Dconfig=\${config}" -P ${stamp_dir}/${name}-${step}-$<CONFIG>-impl.cmake)
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
endif()
# Wrap the command in a script to log output to files.
ExternalProject: Allow generator expressions with LOG_* options (#15287) Use file(GENERATE) to write the logging wrapper scripts to evaluate generator expressions. Use a per-config script names in case the content varies by configuration.
2015-04-21 09:28:21 +03:00
set(script ${stamp_dir}/${name}-${step}-$<CONFIG>.cmake)
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
set(logbase ${stamp_dir}/${name}-${step})
ExternalProject: Allow generator expressions with LOG_* options (#15287) Use file(GENERATE) to write the logging wrapper scripts to evaluate generator expressions. Use a per-config script names in case the content varies by configuration.
2015-04-21 09:28:21 +03:00
set(code "
ExternalProject: Fix $(MAKE) with cygpath on Windows In non-cygwin builds using Cygwin's make tool, use cygpath to transform the value of $(MAKE) to something Windows understands.
2010-08-02 20:02:15 +04:00
${code_cygpath_make}
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
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}'\")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endforeach()
ExternalProject: remove extra newlines from log messages message() already adds a newline.
2014-12-13 02:42:33 +03:00
set(msg \"\${msg}\\nSee also\\n ${logbase}-*.log\")
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
message(FATAL_ERROR \"\${msg}\")
else()
ExternalProject: remove extra newlines from log messages message() already adds a newline.
2014-12-13 02:42:33 +03:00
set(msg \"${name} ${step} command succeeded. See also ${logbase}-*.log\")
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
message(STATUS \"\${msg}\")
endif()
")
ExternalProject: Allow generator expressions with LOG_* options (#15287) Use file(GENERATE) to write the logging wrapper scripts to evaluate generator expressions. Use a per-config script names in case the content varies by configuration.
2015-04-21 09:28:21 +03:00
file(GENERATE OUTPUT "${script}" CONTENT "${code}")
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
set(command ${CMAKE_COMMAND} ${make} ${config} -P ${script})
set(${cmd_var} "${command}" PARENT_SCOPE)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
Eliminate ExternalProject's use of CMAKE_CFG_INTDIR subdir for Makefile generators. It was causing problems with parallel make -j invocations. Keep it for multi-configuration build systems so that Debug and Release stamp files remain separate.
2009-10-01 00:22:36 +04:00
# 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)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
Eliminate ExternalProject's use of CMAKE_CFG_INTDIR subdir for Makefile generators. It was causing problems with parallel make -j invocations. Keep it for multi-configuration build systems so that Debug and Release stamp files remain separate.
2009-10-01 00:22:36 +04:00
ExternalProject: Refactor repeated code into function (#12564) Add "private/internal-use-only" function _ep_get_step_stampfile to get the name of the stamp file for a given step. The functionality provided by this commit should be identical to its parent commit.
2012-04-26 23:26:53 +04:00
function(_ep_get_step_stampfile name step stampfile_var)
ExternalProject_Get_Property(${name} stamp_dir)
Add STEP_TARGETS to ExternalProject module. This commit introduces the ability to add custom targets that correspond to individual ExternalProject steps. The main motivation behind this new feature is to drive sub-project based dashboard steps as external projects with separate targets for update, configure, build and test output. This makes it easy to construct a ctest -S script to drive such a dashboard. With no STEP_TARGETS defined, there are no additional custom targets introduced, to minimize the chatter in the target name space. Clients may define STEP_TARGETS on a per-ExternalProject_Add basis, or at the directory level by setting the EP_STEP_TARGETS directory property.
2010-08-24 01:50:58 +04:00
_ep_get_configuration_subdir_suffix(cfgdir)
ExternalProject: Refactor repeated code into function (#12564) Add "private/internal-use-only" function _ep_get_step_stampfile to get the name of the stamp file for a given step. The functionality provided by this commit should be identical to its parent commit.
2012-04-26 23:26:53 +04:00
set(stampfile "${stamp_dir}${cfgdir}/${name}-${step}")
set(${stampfile_var} "${stampfile}" PARENT_SCOPE)
endfunction()
function(ExternalProject_Add_StepTargets name)
set(steps ${ARGN})
Modules: Check for ARGC before using ARGV# ARGV# could be defined from a parent scope.
2015-02-26 19:26:12 +03:00
if(ARGC GREATER 1 AND "${ARGV1}" STREQUAL "NO_DEPENDS")
ExternalProject: Add independent step targets When adding step targets using ExternalProject_Add_StepTargets, the STEP_TARGETS argument or the EP_STEP_TARGETS property, ExternalProject sets all the dependencies for the main project to that target. Due to this, the update target cannot be used without downloading and building all the dependencies. In order to be able to add step targets that do not depend on other external projects, this patch adds: * An optional "NO_DEPENDS" argument to the ExternalProject_Add_StepTargets function. If this argument is set, then no dependencies are set for the target (file dependencies will still be set). * A new argument INDEPENDENT_STEP_TARGETS to the ExternalProject_Add function and a new directory property EP_INDEPENDENT_STEP_TARGETS that behave like STEP_TARGETS and EP_STEP_TARGETS, but cause the ExternalProject_Add_StepTargets to be called with the NO_DEPENDS argument.
2014-11-03 18:14:35 +03:00
set(no_deps 1)
list(REMOVE_AT steps 0)
endif()
Add STEP_TARGETS to ExternalProject module. This commit introduces the ability to add custom targets that correspond to individual ExternalProject steps. The main motivation behind this new feature is to drive sub-project based dashboard steps as external projects with separate targets for update, configure, build and test output. This makes it easy to construct a ctest -S script to drive such a dashboard. With no STEP_TARGETS defined, there are no additional custom targets introduced, to minimize the chatter in the target name space. Clients may define STEP_TARGETS on a per-ExternalProject_Add basis, or at the directory level by setting the EP_STEP_TARGETS directory property.
2010-08-24 01:50:58 +04:00
foreach(step ${steps})
ExternalProject: Add independent step targets When adding step targets using ExternalProject_Add_StepTargets, the STEP_TARGETS argument or the EP_STEP_TARGETS property, ExternalProject sets all the dependencies for the main project to that target. Due to this, the update target cannot be used without downloading and building all the dependencies. In order to be able to add step targets that do not depend on other external projects, this patch adds: * An optional "NO_DEPENDS" argument to the ExternalProject_Add_StepTargets function. If this argument is set, then no dependencies are set for the target (file dependencies will still be set). * A new argument INDEPENDENT_STEP_TARGETS to the ExternalProject_Add function and a new directory property EP_INDEPENDENT_STEP_TARGETS that behave like STEP_TARGETS and EP_STEP_TARGETS, but cause the ExternalProject_Add_StepTargets to be called with the NO_DEPENDS argument.
2014-11-03 18:14:35 +03:00
if(no_deps AND "${step}" MATCHES "^(configure|build|install|test)$")
message(AUTHOR_WARNING "Using NO_DEPENDS for \"${step}\" step might break parallel builds")
endif()
ExternalProject: Refactor repeated code into function (#12564) Add "private/internal-use-only" function _ep_get_step_stampfile to get the name of the stamp file for a given step. The functionality provided by this commit should be identical to its parent commit.
2012-04-26 23:26:53 +04:00
_ep_get_step_stampfile(${name} ${step} stamp_file)
Add STEP_TARGETS to ExternalProject module. This commit introduces the ability to add custom targets that correspond to individual ExternalProject steps. The main motivation behind this new feature is to drive sub-project based dashboard steps as external projects with separate targets for update, configure, build and test output. This makes it easy to construct a ctest -S script to drive such a dashboard. With no STEP_TARGETS defined, there are no additional custom targets introduced, to minimize the chatter in the target name space. Clients may define STEP_TARGETS on a per-ExternalProject_Add basis, or at the directory level by setting the EP_STEP_TARGETS directory property.
2010-08-24 01:50:58 +04:00
add_custom_target(${name}-${step}
ExternalProject: Refactor repeated code into function (#12564) Add "private/internal-use-only" function _ep_get_step_stampfile to get the name of the stamp file for a given step. The functionality provided by this commit should be identical to its parent commit.
2012-04-26 23:26:53 +04:00
DEPENDS ${stamp_file})
ExternalProject: Add ExternalProject_Add_StepDependencies function The ExternalProject_Add_StepDependencies function add some dependencies for some external project step. The syntax is: ExternalProject_Add_Step_Dependencies(<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 add_dependencies() when adding a dependency for some of the step targets generated by ExternalProject. See also: http://thread.gmane.org/gmane.comp.programming.tools.cmake.devel/8680/focus=8926
2014-11-03 18:14:49 +03:00
set_property(TARGET ${name}-${step} PROPERTY _EP_IS_EXTERNAL_PROJECT_STEP 1)
ExternalProject: Set LABELS property to targets This is useful for using CDash subprojects.
2014-04-07 17:42:44 +04:00
set_property(TARGET ${name}-${step} PROPERTY LABELS ${name})
ExternalProject: Set FOLDER property to targets This is useful when using the USE_FOLDERS global property
2014-04-29 13:41:12 +04:00
set_property(TARGET ${name}-${step} PROPERTY FOLDER "ExternalProjectTargets/${name}")
Ninja: Add the Ninja generator
2011-11-11 09:00:49 +04:00
# Depend on other external projects (target-level).
ExternalProject: Add independent step targets When adding step targets using ExternalProject_Add_StepTargets, the STEP_TARGETS argument or the EP_STEP_TARGETS property, ExternalProject sets all the dependencies for the main project to that target. Due to this, the update target cannot be used without downloading and building all the dependencies. In order to be able to add step targets that do not depend on other external projects, this patch adds: * An optional "NO_DEPENDS" argument to the ExternalProject_Add_StepTargets function. If this argument is set, then no dependencies are set for the target (file dependencies will still be set). * A new argument INDEPENDENT_STEP_TARGETS to the ExternalProject_Add function and a new directory property EP_INDEPENDENT_STEP_TARGETS that behave like STEP_TARGETS and EP_STEP_TARGETS, but cause the ExternalProject_Add_StepTargets to be called with the NO_DEPENDS argument.
2014-11-03 18:14:35 +03:00
if(NOT no_deps)
get_property(deps TARGET ${name} PROPERTY _EP_DEPENDS)
foreach(arg IN LISTS deps)
add_dependencies(${name}-${step} ${arg})
endforeach()
endif()
Add STEP_TARGETS to ExternalProject module. This commit introduces the ability to add custom targets that correspond to individual ExternalProject steps. The main motivation behind this new feature is to drive sub-project based dashboard steps as external projects with separate targets for update, configure, build and test output. This makes it easy to construct a ctest -S script to drive such a dashboard. With no STEP_TARGETS defined, there are no additional custom targets introduced, to minimize the chatter in the target name space. Clients may define STEP_TARGETS on a per-ExternalProject_Add basis, or at the directory level by setting the EP_STEP_TARGETS directory property.
2010-08-24 01:50:58 +04:00
endforeach()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
Add STEP_TARGETS to ExternalProject module. This commit introduces the ability to add custom targets that correspond to individual ExternalProject steps. The main motivation behind this new feature is to drive sub-project based dashboard steps as external projects with separate targets for update, configure, build and test output. This makes it easy to construct a ctest -S script to drive such a dashboard. With no STEP_TARGETS defined, there are no additional custom targets introduced, to minimize the chatter in the target name space. Clients may define STEP_TARGETS on a per-ExternalProject_Add basis, or at the directory level by setting the EP_STEP_TARGETS directory property.
2010-08-24 01:50:58 +04:00
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
function(ExternalProject_Add_Step name step)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
set(cmf_dir ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles)
Eliminate ExternalProject's use of CMAKE_CFG_INTDIR subdir for Makefile generators. It was causing problems with parallel make -j invocations. Keep it for multi-configuration build systems so that Debug and Release stamp files remain separate.
2009-10-01 00:22:36 +04:00
_ep_get_configuration_subdir_suffix(cfgdir)
ExternalProject: Refactor repeated code into function (#12564) Add "private/internal-use-only" function _ep_get_step_stampfile to get the name of the stamp file for a given step. The functionality provided by this commit should be identical to its parent commit.
2012-04-26 23:26:53 +04:00
set(complete_stamp_file "${cmf_dir}${cfgdir}/${name}-complete")
_ep_get_step_stampfile(${name} ${step} stamp_file)
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
_ep_parse_arguments(ExternalProject_Add_Step
ExternalProject: Refactor repeated code into function (#12564) Add "private/internal-use-only" function _ep_get_step_stampfile to get the name of the stamp file for a given step. The functionality provided by this commit should be identical to its parent commit.
2012-04-26 23:26:53 +04:00
${name} _EP_${step}_ "${ARGN}")
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
ExternalProject: Add EXCLUDE_FROM_MAIN option to ExternalProject_Add_Step When adding a new step using ExternalProject_Add_Step, the main target will depend on this step. This option allows one to add a step that will not be executed when the main target for the external project is executed.
2013-12-04 13:05:50 +04:00
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()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
# Steps depending on this step.
get_property(dependers TARGET ${name} PROPERTY _EP_${step}_DEPENDERS)
foreach(depender IN LISTS dependers)
ExternalProject: Refactor repeated code into function (#12564) Add "private/internal-use-only" function _ep_get_step_stampfile to get the name of the stamp file for a given step. The functionality provided by this commit should be identical to its parent commit.
2012-04-26 23:26:53 +04:00
_ep_get_step_stampfile(${name} ${depender} depender_stamp_file)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
add_custom_command(APPEND
ExternalProject: Refactor repeated code into function (#12564) Add "private/internal-use-only" function _ep_get_step_stampfile to get the name of the stamp file for a given step. The functionality provided by this commit should be identical to its parent commit.
2012-04-26 23:26:53 +04:00
OUTPUT ${depender_stamp_file}
DEPENDS ${stamp_file}
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
)
endforeach()
# Dependencies on files.
get_property(depends TARGET ${name} PROPERTY _EP_${step}_DEPENDS)
ExternalProject: Add options to specify BYPRODUCTS (#14963) The external project's build process may generate byproducts on which other rules in the driving project's build later depend. Provide a way for the driving project to specify what byproducts it expects to be made available by the custom commands that drive the external project.
2014-11-14 03:26:36 +03:00
# Byproducts of the step.
get_property(byproducts TARGET ${name} PROPERTY _EP_${step}_BYPRODUCTS)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
# Dependencies on steps.
get_property(dependees TARGET ${name} PROPERTY _EP_${step}_DEPENDEES)
foreach(dependee IN LISTS dependees)
ExternalProject: Refactor repeated code into function (#12564) Add "private/internal-use-only" function _ep_get_step_stampfile to get the name of the stamp file for a given step. The functionality provided by this commit should be identical to its parent commit.
2012-04-26 23:26:53 +04:00
_ep_get_step_stampfile(${name} ${dependee} dependee_stamp_file)
list(APPEND depends ${dependee_stamp_file})
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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.
ExternalProject: Replace placeholder tokens in BYPRODUCTS This allows the developer to specify the byproducts relative to the binary directory without the need to set the binary directory location explicitly.
2015-03-06 13:43:16 +03:00
_ep_replace_location_tags(${name} comment command work_dir byproducts)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
# 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)
ExternalProject: Refactor repeated code into function (#12564) Add "private/internal-use-only" function _ep_get_step_stampfile to get the name of the stamp file for a given step. The functionality provided by this commit should be identical to its parent commit.
2012-04-26 23:26:53 +04:00
set_property(SOURCE ${stamp_file} PROPERTY SYMBOLIC 1)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
set(touch)
ExternalProject: Allow ALWAYS step property to be switched (#15368) Within an existing build tree, if the stamp for a step already exists when one activates the ALWAYS option, we still want it to always build. Remove the step stamp file during CMake configuration to ensure it does not exist when the ALWAYS option is enabled.
2015-01-23 21:28:49 +03:00
# 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()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
else()
ExternalProject: Refactor repeated code into function (#12564) Add "private/internal-use-only" function _ep_get_step_stampfile to get the name of the stamp file for a given step. The functionality provided by this commit should be identical to its parent commit.
2012-04-26 23:26:53 +04:00
set(touch ${CMAKE_COMMAND} -E touch ${stamp_file})
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
endif()
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
# Wrap with log script?
get_property(log TARGET ${name} PROPERTY _EP_${step}_LOG)
Detect CMake warnings and errors in build output. Fix niggly in ExternalProject that would inadvertently create a log file of output when a command was explicitly set to the empty string. Also, increase the default value for showing context around build errors to 10 lines, up from 6. Also add the ability to customize this setting so that users can put it back to 6 or even lower if they want, or show more if they want.
2010-07-02 21:22:30 +04:00
if(command AND log)
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
_ep_write_log_script(${name} ${step} command)
endif()
ExternalProject: Always add a command to a step 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. This patch sets an empty echo command that does nothing to avoid this issue.
2014-11-05 02:31:32 +03:00
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()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
add_custom_command(
ExternalProject: Refactor repeated code into function (#12564) Add "private/internal-use-only" function _ep_get_step_stampfile to get the name of the stamp file for a given step. The functionality provided by this commit should be identical to its parent commit.
2012-04-26 23:26:53 +04:00
OUTPUT ${stamp_file}
ExternalProject: Add options to specify BYPRODUCTS (#14963) The external project's build process may generate byproducts on which other rules in the driving project's build later depend. Provide a way for the driving project to specify what byproducts it expects to be made available by the custom commands that drive the external project.
2014-11-14 03:26:36 +03:00
BYPRODUCTS ${byproducts}
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
COMMENT ${comment}
COMMAND ${command}
COMMAND ${touch}
DEPENDS ${depends}
WORKING_DIRECTORY ${work_dir}
VERBATIM
)
ExternalProject: Add ExternalProject_Add_StepDependencies function The ExternalProject_Add_StepDependencies function add some dependencies for some external project step. The syntax is: ExternalProject_Add_Step_Dependencies(<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 add_dependencies() when adding a dependency for some of the step targets generated by ExternalProject. See also: http://thread.gmane.org/gmane.comp.programming.tools.cmake.devel/8680/focus=8926
2014-11-03 18:14:49 +03:00
set_property(TARGET ${name} APPEND PROPERTY _EP_STEPS ${step})
Add STEP_TARGETS to ExternalProject module. This commit introduces the ability to add custom targets that correspond to individual ExternalProject steps. The main motivation behind this new feature is to drive sub-project based dashboard steps as external projects with separate targets for update, configure, build and test output. This makes it easy to construct a ctest -S script to drive such a dashboard. With no STEP_TARGETS defined, there are no additional custom targets introduced, to minimize the chatter in the target name space. Clients may define STEP_TARGETS on a per-ExternalProject_Add basis, or at the directory level by setting the EP_STEP_TARGETS directory property.
2010-08-24 01:50:58 +04:00
# 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()
ExternalProject: Add independent step targets When adding step targets using ExternalProject_Add_StepTargets, the STEP_TARGETS argument or the EP_STEP_TARGETS property, ExternalProject sets all the dependencies for the main project to that target. Due to this, the update target cannot be used without downloading and building all the dependencies. In order to be able to add step targets that do not depend on other external projects, this patch adds: * An optional "NO_DEPENDS" argument to the ExternalProject_Add_StepTargets function. If this argument is set, then no dependencies are set for the target (file dependencies will still be set). * A new argument INDEPENDENT_STEP_TARGETS to the ExternalProject_Add function and a new directory property EP_INDEPENDENT_STEP_TARGETS that behave like STEP_TARGETS and EP_STEP_TARGETS, but cause the ExternalProject_Add_StepTargets to be called with the NO_DEPENDS argument.
2014-11-03 18:14:35 +03:00
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()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
ExternalProject: Add ExternalProject_Add_StepDependencies function The ExternalProject_Add_StepDependencies function add some dependencies for some external project step. The syntax is: ExternalProject_Add_Step_Dependencies(<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 add_dependencies() when adding a dependency for some of the step targets generated by ExternalProject. See also: http://thread.gmane.org/gmane.comp.programming.tools.cmake.devel/8680/focus=8926
2014-11-03 18:14:49 +03:00
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()
ExternalProject: Allow dependencies on INTERFACE libraries Respect INTERFACE library property whitelist. Check that a target has type "UTILITY" before querying other properties.
2015-04-21 18:32:22 +03:00
get_property(type TARGET ${name} PROPERTY TYPE)
if(NOT type STREQUAL "UTILITY")
message(FATAL_ERROR "Target \"${name}\" was not generated by ExternalProject_Add.")
endif()
ExternalProject: Add ExternalProject_Add_StepDependencies function The ExternalProject_Add_StepDependencies function add some dependencies for some external project step. The syntax is: ExternalProject_Add_Step_Dependencies(<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 add_dependencies() when adding a dependency for some of the step targets generated by ExternalProject. See also: http://thread.gmane.org/gmane.comp.programming.tools.cmake.devel/8680/focus=8926
2014-11-03 18:14:49 +03:00
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})
ExternalProject: Allow dependencies on INTERFACE libraries Respect INTERFACE library property whitelist. Check that a target has type "UTILITY" before querying other properties.
2015-04-21 18:32:22 +03:00
get_property(type TARGET ${name}-${step} PROPERTY TYPE)
if(NOT type STREQUAL "UTILITY")
message(FATAL_ERROR "Target \"${name}-${step}\" was not generated by ExternalProject_Add_StepTargets.")
endif()
ExternalProject: Add ExternalProject_Add_StepDependencies function The ExternalProject_Add_StepDependencies function add some dependencies for some external project step. The syntax is: ExternalProject_Add_Step_Dependencies(<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 add_dependencies() when adding a dependency for some of the step targets generated by ExternalProject. See also: http://thread.gmane.org/gmane.comp.programming.tools.cmake.devel/8680/focus=8926
2014-11-03 18:14:49 +03:00
get_property(is_ep_step TARGET ${name}-${step} PROPERTY _EP_IS_EXTERNAL_PROJECT_STEP)
if(NOT is_ep_step)
ExternalProject: Fix error message typo
2015-04-21 18:32:13 +03:00
message(FATAL_ERROR "Target \"${name}-${step}\" was not generated by ExternalProject_Add_StepTargets.")
ExternalProject: Add ExternalProject_Add_StepDependencies function The ExternalProject_Add_StepDependencies function add some dependencies for some external project step. The syntax is: ExternalProject_Add_Step_Dependencies(<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 add_dependencies() when adding a dependency for some of the step targets generated by ExternalProject. See also: http://thread.gmane.org/gmane.comp.programming.tools.cmake.devel/8680/focus=8926
2014-11-03 18:14:49 +03:00
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()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
function(_ep_add_mkdir_command name)
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
ExternalProject_Get_Property(${name}
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
source_dir binary_dir install_dir stamp_dir download_dir tmp_dir)
Eliminate ExternalProject's use of CMAKE_CFG_INTDIR subdir for Makefile generators. It was causing problems with parallel make -j invocations. Keep it for multi-configuration build systems so that Debug and Release stamp files remain separate.
2009-10-01 00:22:36 +04:00
_ep_get_configuration_subdir_suffix(cfgdir)
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
ExternalProject_Add_Step(${name} mkdir
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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}
Eliminate ExternalProject's use of CMAKE_CFG_INTDIR subdir for Makefile generators. It was causing problems with parallel make -j invocations. Keep it for multi-configuration build systems so that Debug and Release stamp files remain separate.
2009-10-01 00:22:36 +04:00
COMMAND ${CMAKE_COMMAND} -E make_directory ${stamp_dir}${cfgdir}
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
COMMAND ${CMAKE_COMMAND} -E make_directory ${download_dir}
)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
function(_ep_get_git_version git_EXECUTABLE git_version_var)
if(git_EXECUTABLE)
execute_process(
COMMAND "${git_EXECUTABLE}" --version
OUTPUT_VARIABLE ov
ExternalProject: Fix git.cmd version detection When GIT_EXECUTABLE points at ".../Git/cmd/git.cmd" in an msysGit installation we previously failed to detect the version number in a subtle case. The "git.cmd" assumes 'chcp' is in PATH. It is typically available at "C:\Windows\System32\chcp.com". On 64-bit Windows the File System Redirector maps this location to "C:\Windows\SysWOW64\chcp.com" for 32-bit processes. However, some Windows installations fail to provide chcp.com at this path. Whenever git.cmd runs in a 32-bit command shell, as it does under a 32-bit CMake binary, it reports 'chcp' is not recognized as an internal or external command, operable program or batch file. on stderr. Capture stderr separately so it does not affect parsing of the version number. See also msysGit issue 358: http://code.google.com/p/msysgit/issues/detail?id=358 Note that FindGit prefers "git.cmd" over "git.exe" because it sets up the proper HOME environment variable necessary for Git ssh connections to work the same as they do from the Git bash prompt.
2012-01-10 23:38:22 +04:00
ERROR_VARIABLE ev
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
OUTPUT_STRIP_TRAILING_WHITESPACE
)
string(REGEX REPLACE "^git version (.+)$" "\\1" version "${ov}")
set(${git_version_var} "${version}" PARENT_SCOPE)
endif()
endfunction()
Fix issue #10346. Error if SOURCE_DIR is empty. See http://public.kitware.com/Bug/view.php?id=10346. The proposed patch for the issue could not be applied as is because the SOURCE_DIR always exists for an ExternalProject_Add call by the time we get to the place to emit the potential error. The fix is to emit the error only if the source dir is empty. By which, I mean devoid of files and subdirectories. If SOURCE_DIR is used by itself, without any DOWNLOAD_COMMAND or repository info, then it implies that the SOURCE_DIR is ready to build as-is without need for a download step. Clearly, if it is empty, then it is not ready to build as is. So complain if the SOURCE_DIR is empty.
2010-06-10 02:22:58 +04:00
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()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
function(_ep_add_download_command name)
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
ExternalProject_Get_Property(${name} source_dir stamp_dir download_dir tmp_dir)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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)
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
get_property(git_repository TARGET ${name} PROPERTY _EP_GIT_REPOSITORY)
ExternalProject: Add Mercurial (hg) repository support Add options HG_REPOSITORY and HG_TAG to specify an external project hosted in a Mercurial repository. Teach ExternalProject to clone the repository and update from it. Extend the ExternalProject test to try a Mercurial repository when hg is available.
2012-08-15 18:09:43 +04:00
get_property(hg_repository TARGET ${name} PROPERTY _EP_HG_REPOSITORY )
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
get_property(url TARGET ${name} PROPERTY _EP_URL)
ExternalProject: Add DOWNLOAD_NAME option Some download URLs do not have the filename embedded in the url. Add an interface to specify the local filename explicitly. Suggested-by: James Goppert <james.goppert@gmail.com>
2012-09-19 00:02:00 +04:00
get_property(fname TARGET ${name} PROPERTY _EP_DOWNLOAD_NAME)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
# 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)
ExternalProject: Find VCS packages quietly This keeps the VCS packages out from FeatureSummary output, unless the INCLUDE_QUIET_PACKAGES is used.
2013-11-18 15:24:24 +04:00
find_package(CVS QUIET)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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)
ExternalProject: Find VCS packages quietly This keeps the VCS packages out from FeatureSummary output, unless the INCLUDE_QUIET_PACKAGES is used.
2013-11-18 15:24:24 +04:00
find_package(Subversion QUIET)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
if(NOT Subversion_SVN_EXECUTABLE)
message(FATAL_ERROR "error: could not find svn for checkout of ${name}")
endif()
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
get_property(svn_revision TARGET ${name} PROPERTY _EP_SVN_REVISION)
Add svn user name and password to ExternalProject. Thanks to JCFR for the leg work.
2010-05-26 22:50:19 +04:00
get_property(svn_username TARGET ${name} PROPERTY _EP_SVN_USERNAME)
get_property(svn_password TARGET ${name} PROPERTY _EP_SVN_PASSWORD)
ExternalProject: Add SVN_TRUST_CERT argument Which adds --non-interactive and --trust-server-cert to the svn checkout and update command lines. This allows ExternalProject clients to pull from an https:// based svn server even though the server may not have a valid or trusted certificate. Caveat emptor: I would NOT recommend using this except as a short-term work-around. Rather, the server should have a valid, trusted certificate, or the client should be using "http" instead of "https".
2011-04-12 00:34:58 +04:00
get_property(svn_trust_cert TARGET ${name} PROPERTY _EP_SVN_TRUST_CERT)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
Add svn user name and password to ExternalProject. Thanks to JCFR for the leg work.
2010-05-26 22:50:19 +04:00
set(repository "${svn_repository} user=${svn_username} password=${svn_password}")
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
set(module)
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
set(tag ${svn_revision})
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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}'")
ExternalProject: No svn --username if empty (#11173) Nor --password. But please do if non-empty. Thank you.
2010-10-23 00:09:07 +04:00
set(svn_user_pw_args "")
ExternalProject: Allow blank SVN_USERNAME/SVN_PASSWORD (#14128) With SVN_USERNAME "" SVN_PASSWORD "" in an ExternalProject_Add() call, the blank username and password will be passed to the svn checkout/update step commands.
2013-05-06 16:30:56 +04:00
if(DEFINED svn_username)
ExternalProject: No svn --username if empty (#11173) Nor --password. But please do if non-empty. Thank you.
2010-10-23 00:09:07 +04:00
set(svn_user_pw_args ${svn_user_pw_args} "--username=${svn_username}")
endif()
ExternalProject: Allow blank SVN_USERNAME/SVN_PASSWORD (#14128) With SVN_USERNAME "" SVN_PASSWORD "" in an ExternalProject_Add() call, the blank username and password will be passed to the svn checkout/update step commands.
2013-05-06 16:30:56 +04:00
if(DEFINED svn_password)
ExternalProject: No svn --username if empty (#11173) Nor --password. But please do if non-empty. Thank you.
2010-10-23 00:09:07 +04:00
set(svn_user_pw_args ${svn_user_pw_args} "--password=${svn_password}")
endif()
ExternalProject: Add SVN_TRUST_CERT argument Which adds --non-interactive and --trust-server-cert to the svn checkout and update command lines. This allows ExternalProject clients to pull from an https:// based svn server even though the server may not have a valid or trusted certificate. Caveat emptor: I would NOT recommend using this except as a short-term work-around. Rather, the server should have a valid, trusted certificate, or the client should be using "http" instead of "https".
2011-04-12 00:34:58 +04:00
if(svn_trust_cert)
ExternalProject: Always use --non-interactive with svn The previous commit added --non-interactive as a "side effect" of turning on SVN_TRUST_CERT. While reviewing that commit, we decided all ExternalProject svn usage should be non-interactive. That way, if there's any sort of problem, svn will return an error right away rather than hang forever waiting for input...
2011-04-18 19:34:00 +04:00
set(svn_trust_cert_args --trust-server-cert)
ExternalProject: Add SVN_TRUST_CERT argument Which adds --non-interactive and --trust-server-cert to the svn checkout and update command lines. This allows ExternalProject clients to pull from an https:// based svn server even though the server may not have a valid or trusted certificate. Caveat emptor: I would NOT recommend using this except as a short-term work-around. Rather, the server should have a valid, trusted certificate, or the client should be using "http" instead of "https".
2011-04-12 00:34:58 +04:00
endif()
Add svn user name and password to ExternalProject. Thanks to JCFR for the leg work.
2010-05-26 22:50:19 +04:00
set(cmd ${Subversion_SVN_EXECUTABLE} co ${svn_repository} ${svn_revision}
ExternalProject: Always use --non-interactive with svn The previous commit added --non-interactive as a "side effect" of turning on SVN_TRUST_CERT. While reviewing that commit, we decided all ExternalProject svn usage should be non-interactive. That way, if there's any sort of problem, svn will return an error right away rather than hang forever waiting for input...
2011-04-18 19:34:00 +04:00
--non-interactive ${svn_trust_cert_args} ${svn_user_pw_args} ${src_name})
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
list(APPEND depends ${stamp_dir}/${name}-svninfo.txt)
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
elseif(git_repository)
ExternalProject: Find VCS packages quietly This keeps the VCS packages out from FeatureSummary output, unless the INCLUDE_QUIET_PACKAGES is used.
2013-11-18 15:24:24 +04:00
find_package(Git QUIET)
Add FindGit module. Use it from ExternalProject and the ExternalProject test's CMakeLists file rather than having duplicate find_program calls. Add logic so that we do not try to use *.cmd variants of git programs when using the MSYS Makefiles generator. Should fix the last remaining dashboard issue with the new ExternalProject git support additions. Also, correct minor problem regarding placement of the local git repo during test execution. On clean builds, it was being placed incorrectly because of the ../.. relative reference. Use an absolute path to place the local git repo in the proper directory, and only use the relative reference when referring to it.
2010-06-04 01:30:07 +04:00
if(NOT GIT_EXECUTABLE)
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
message(FATAL_ERROR "error: could not find git for clone of ${name}")
endif()
# The git submodule update '--recursive' flag requires git >= v1.6.5
#
Add FindGit module. Use it from ExternalProject and the ExternalProject test's CMakeLists file rather than having duplicate find_program calls. Add logic so that we do not try to use *.cmd variants of git programs when using the MSYS Makefiles generator. Should fix the last remaining dashboard issue with the new ExternalProject git support additions. Also, correct minor problem regarding placement of the local git repo during test execution. On clean builds, it was being placed incorrectly because of the ../.. relative reference. Use an absolute path to place the local git repo in the proper directory, and only use the relative reference when referring to it.
2010-06-04 01:30:07 +04:00
_ep_get_git_version("${GIT_EXECUTABLE}" git_version)
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
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()
ExternalProject: Add option GIT_SUBMODULES This option allows to filter the submodules that are checked out. Add a simple testcase for GIT_SUBMODULES option passing an empty list.
2014-01-09 18:07:10 +04:00
get_property(git_submodules TARGET ${name} PROPERTY _EP_GIT_SUBMODULES)
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
ExternalProject: Avoid unnecessary git clones (#12564) In the case of git, only track the repository in the repository info dependency tracking file. Not the tag. The download step should only re-run if the repository changes. The download step should NOT re-run if the tag changes. The update step is an 'always' re-running step, and so should already re-run, unless it's been eliminated by use of UPDATE_COMMAND ""
2012-04-26 01:30:18 +04:00
# 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.
#
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
set(repository ${git_repository})
set(module)
ExternalProject: Avoid unnecessary git clones (#12564) In the case of git, only track the repository in the repository info dependency tracking file. Not the tag. The download step should only re-run if the repository changes. The download step should NOT re-run if the tag changes. The update step is an 'always' re-running step, and so should already re-run, unless it's been eliminated by use of UPDATE_COMMAND ""
2012-04-26 01:30:18 +04:00
set(tag)
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
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}
ExternalProject: Add option GIT_SUBMODULES This option allows to filter the submodules that are checked out. Add a simple testcase for GIT_SUBMODULES option passing an empty list.
2014-01-09 18:07:10 +04:00
${GIT_EXECUTABLE} ${git_repository} ${git_tag} "${git_submodules}" ${src_name} ${work_dir}
ExternalProject: Avoid repeated git clone operations (#12564) By tracking a stamp file within the git clone script itself. Avoids a 2nd git clone operation after switching from Debug to Release builds in Visual Studio, or vice-versa.
2012-04-28 19:40:12 +04:00
${stamp_dir}/${name}-gitinfo.txt ${stamp_dir}/${name}-gitclone-lastrun.txt
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
)
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)
ExternalProject: Add Mercurial (hg) repository support Add options HG_REPOSITORY and HG_TAG to specify an external project hosted in a Mercurial repository. Teach ExternalProject to clone the repository and update from it. Extend the ExternalProject test to try a Mercurial repository when hg is available.
2012-08-15 18:09:43 +04:00
elseif(hg_repository)
ExternalProject: Find VCS packages quietly This keeps the VCS packages out from FeatureSummary output, unless the INCLUDE_QUIET_PACKAGES is used.
2013-11-18 15:24:24 +04:00
find_package(Hg QUIET)
ExternalProject: Add Mercurial (hg) repository support Add options HG_REPOSITORY and HG_TAG to specify an external project hosted in a Mercurial repository. Teach ExternalProject to clone the repository and update from it. Extend the ExternalProject test to try a Mercurial repository when hg is available.
2012-08-15 18:09:43 +04:00
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)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
elseif(url)
get_filename_component(work_dir "${source_dir}" PATH)
ExternalProject: Generalize URL_MD5 option to URL_HASH Add support for SHA algorithms.
2012-09-11 18:53:17 +04:00
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()
Improve FILE(DOWNLOAD) and ExternalProject. Improve FILE(DOWNLOAD ...): - Add percent complete progress output to the FILE DOWNLOAD command. This progress output is off by default to preserve existing behavior. To turn it on, pass SHOW_PROGRESS as an argument. - Add EXPECTED_MD5 argument. Verify that the downloaded file has the expected md5 sum after download is complete. - Add documentation for SHOW_PROGRESS and EXPECTED_MD5. When the destination file exists already and has the expected md5 sum, then do not bother re-downloading the file. ("Short circuit" return.) Also, add a test that checks for the status output indicating that the short circuit behavior is actually occurring. Use a binary file for the test so that the md5 sum is guaranteed to be the same on all platforms regardless of "shifting text file line ending" issues. Improve ExternalProject: - Add argument URL_MD5. - Add verify step that compares md5 sum of .tar.gz file before extracting it. - Add md5 check to download step, too, to prevent unnecessary downloads. - Emit a warning message when a file is not verified. Indicate that the file may be corrupt or that no checksum was specified.
2010-05-27 20:21:56 +04:00
get_property(md5 TARGET ${name} PROPERTY _EP_URL_MD5)
ExternalProject: Generalize URL_MD5 option to URL_HASH Add support for SHA algorithms.
2012-09-11 18:53:17 +04:00
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()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
set(repository "external project URL")
set(module "${url}")
ExternalProject: Generalize URL_MD5 option to URL_HASH Add support for SHA algorithms.
2012-09-11 18:53:17 +04:00
set(tag "${hash}")
ExternalProject: Reattempt download when verification fails. When downloading an URL with ExternalProject, reattempt the download three times if the file hash verification fails. The re-attempt is limited to non-local URL's. The same download CMake script is re-used after removing any file that resulted from the previous download attempt. Up to three re-attempts are performed.
2014-01-16 01:31:23 +04:00
set(retries 0)
set(download_script "")
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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?
ExternalProject: Add DOWNLOAD_NAME option Some download URLs do not have the filename embedded in the url. Add an interface to specify the local filename explicitly. Suggested-by: James Goppert <james.goppert@gmail.com>
2012-09-19 00:02:00 +04:00
if("x${fname}" STREQUAL "x")
string(REGEX MATCH "[^/\\?]*$" fname "${url}")
endif()
ExternalProject: Recognize lzma-compressed files (#13515) Add .7z, .tar.xz, and .txz file extensions. Inspired-by: Joke de Buhr <joke@seiken.de> Inspired-by: David Cole <DLRdave@aol.com>
2014-07-23 23:54:04 +04:00
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}")
ExternalProject: Extract file names from more urls Notably, downloads from sourceforge.net and gitweb snapshots.
2011-03-05 00:51:46 +03:00
set(fname "${CMAKE_MATCH_1}")
endif()
ExternalProject: Recognize lzma-compressed files (#13515) Add .7z, .tar.xz, and .txz file extensions. Inspired-by: Joke de Buhr <joke@seiken.de> Inspired-by: David Cole <DLRdave@aol.com>
2014-07-23 23:54:04 +04:00
if(NOT "${fname}" MATCHES "(\\.|=)(7z|tar|tar\\.bz2|tar\\.gz|tar\\.xz|tbz2|tgz|txz|zip)$")
ENH: Check tarball filename in ep_add This teaches the ExternalProject module to check the download URL file name. If it is not a tarball (.tar, .tgz, .tar.gz) it is an error because UntarFile does not yet understand other archive formats.
2009-07-13 18:46:32 +04:00
message(FATAL_ERROR "Could not extract tarball filename from url:\n ${url}")
endif()
ExternalProject: Extract file names from more urls Notably, downloads from sourceforge.net and gitweb snapshots.
2011-03-05 00:51:46 +03:00
string(REPLACE ";" "-" fname "${fname}")
ENH: Check tarball filename in ep_add This teaches the ExternalProject module to check the download URL file name. If it is not a tarball (.tar, .tgz, .tar.gz) it is an error because UntarFile does not yet understand other archive formats.
2009-07-13 18:46:32 +04:00
set(file ${download_dir}/${fname})
Fix issue #9764 - add TIMEOUT arg to ExternalProject_Add so that callers have explicit control over the amount of time they are willing to wait for a download step. Default to no timeout, which means just run download for however long it takes.
2009-12-11 23:04:55 +03:00
get_property(timeout TARGET ${name} PROPERTY _EP_TIMEOUT)
ExternalProject: Add option to disable download progress (#14807) Add a DOWNLOAD_NO_PROGRESS option to disable progress reports while downloading source tarballs.
2014-03-17 19:24:20 +04:00
get_property(no_progress TARGET ${name} PROPERTY _EP_DOWNLOAD_NO_PROGRESS)
Rename SSL terminology to TLS TLS has superseded SSL so rename the recently added file(DOWNLOAD) and ExternalProject options using the newer terminology. Drop "CURLOPT" from names because curl is an implementation detail.
2012-09-14 23:40:09 +04:00
get_property(tls_verify TARGET ${name} PROPERTY _EP_TLS_VERIFY)
get_property(tls_cainfo TARGET ${name} PROPERTY _EP_TLS_CAINFO)
ExternalProject: Reattempt download when verification fails. When downloading an URL with ExternalProject, reattempt the download three times if the file hash verification fails. The re-attempt is limited to non-local URL's. The same download CMake script is re-used after removing any file that resulted from the previous download attempt. Up to three re-attempts are performed.
2014-01-16 01:31:23 +04:00
set(download_script "${stamp_dir}/download-${name}.cmake")
ExternalProject: Add option to disable download progress (#14807) Add a DOWNLOAD_NO_PROGRESS option to disable progress reports while downloading source tarballs.
2014-03-17 19:24:20 +04:00
_ep_write_downloadfile_script("${download_script}" "${url}" "${file}" "${timeout}" "${no_progress}" "${hash}" "${tls_verify}" "${tls_cainfo}")
ExternalProject: Reattempt download when verification fails. When downloading an URL with ExternalProject, reattempt the download three times if the file hash verification fails. The re-attempt is limited to non-local URL's. The same download CMake script is re-used after removing any file that resulted from the previous download attempt. Up to three re-attempts are performed.
2014-01-16 01:31:23 +04:00
set(cmd ${CMAKE_COMMAND} -P "${download_script}"
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
COMMAND)
ExternalProject: Reattempt download when verification fails. When downloading an URL with ExternalProject, reattempt the download three times if the file hash verification fails. The re-attempt is limited to non-local URL's. The same download CMake script is re-used after removing any file that resulted from the previous download attempt. Up to three re-attempts are performed.
2014-01-16 01:31:23 +04:00
set(retries 3)
Improve FILE(DOWNLOAD) and ExternalProject. Improve FILE(DOWNLOAD ...): - Add percent complete progress output to the FILE DOWNLOAD command. This progress output is off by default to preserve existing behavior. To turn it on, pass SHOW_PROGRESS as an argument. - Add EXPECTED_MD5 argument. Verify that the downloaded file has the expected md5 sum after download is complete. - Add documentation for SHOW_PROGRESS and EXPECTED_MD5. When the destination file exists already and has the expected md5 sum, then do not bother re-downloading the file. ("Short circuit" return.) Also, add a test that checks for the status output indicating that the short circuit behavior is actually occurring. Use a binary file for the test so that the md5 sum is guaranteed to be the same on all platforms regardless of "shifting text file line ending" issues. Improve ExternalProject: - Add argument URL_MD5. - Add verify step that compares md5 sum of .tar.gz file before extracting it. - Add md5 check to download step, too, to prevent unnecessary downloads. - Emit a warning message when a file is not verified. Indicate that the file may be corrupt or that no checksum was specified.
2010-05-27 20:21:56 +04:00
set(comment "Performing download step (download, verify and extract) for '${name}'")
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
else()
set(file "${url}")
Improve FILE(DOWNLOAD) and ExternalProject. Improve FILE(DOWNLOAD ...): - Add percent complete progress output to the FILE DOWNLOAD command. This progress output is off by default to preserve existing behavior. To turn it on, pass SHOW_PROGRESS as an argument. - Add EXPECTED_MD5 argument. Verify that the downloaded file has the expected md5 sum after download is complete. - Add documentation for SHOW_PROGRESS and EXPECTED_MD5. When the destination file exists already and has the expected md5 sum, then do not bother re-downloading the file. ("Short circuit" return.) Also, add a test that checks for the status output indicating that the short circuit behavior is actually occurring. Use a binary file for the test so that the md5 sum is guaranteed to be the same on all platforms regardless of "shifting text file line ending" issues. Improve ExternalProject: - Add argument URL_MD5. - Add verify step that compares md5 sum of .tar.gz file before extracting it. - Add md5 check to download step, too, to prevent unnecessary downloads. - Emit a warning message when a file is not verified. Indicate that the file may be corrupt or that no checksum was specified.
2010-05-27 20:21:56 +04:00
set(comment "Performing download step (verify and extract) for '${name}'")
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
endif()
ExternalProject: Reattempt download when verification fails. When downloading an URL with ExternalProject, reattempt the download three times if the file hash verification fails. The re-attempt is limited to non-local URL's. The same download CMake script is re-used after removing any file that resulted from the previous download attempt. Up to three re-attempts are performed.
2014-01-16 01:31:23 +04:00
_ep_write_verifyfile_script("${stamp_dir}/verify-${name}.cmake" "${file}" "${hash}" "${retries}" "${download_script}")
ExternalProject: Add missing COMMAND keyword Commit f67139ae added running a verify script in between running the download and extract scripts. Since then, it has always been missing the COMMAND keyword added in this commit. It worked anyway (semi-accidentally) by running a command line like: cmake -P script1.cmake cmake -P script2.cmake CMake, when running -P scripts on the command line, runs them in order, and apparently ignores spurious arguments in between (the middle "cmake" in the above example) and so, all appeared to work as intended. This commit adds the missing keyword and the commands that run are now two separate sequential cmake invocations like: cmake -P script1.cmake cmake -P script2.cmake ...which was the original intent of commit f67139ae
2012-04-22 17:10:01 +04:00
list(APPEND cmd ${CMAKE_COMMAND} -P ${stamp_dir}/verify-${name}.cmake
COMMAND)
Qualify name of extraction location with ExternalProject name. Avoid issues with two external projects trying to extract two separate trees at the same time into the same location. Should fix the sporadically failing ExternalProject test on the dashboards for parallel builds.
2010-06-23 15:04:06 +04:00
_ep_write_extractfile_script("${stamp_dir}/extract-${name}.cmake" "${name}" "${file}" "${source_dir}")
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
list(APPEND cmd ${CMAKE_COMMAND} -P ${stamp_dir}/extract-${name}.cmake)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
endif()
else()
Fix issue #10346. Error if SOURCE_DIR is empty. See http://public.kitware.com/Bug/view.php?id=10346. The proposed patch for the issue could not be applied as is because the SOURCE_DIR always exists for an ExternalProject_Add call by the time we get to the place to emit the potential error. The fix is to emit the error only if the source dir is empty. By which, I mean devoid of files and subdirectories. If SOURCE_DIR is used by itself, without any DOWNLOAD_COMMAND or repository info, then it implies that the SOURCE_DIR is ready to build as-is without need for a download step. Clearly, if it is empty, then it is not ready to build as is. So complain if the SOURCE_DIR is empty.
2010-06-10 02:22:58 +04:00
_ep_is_dir_empty("${source_dir}" empty)
if(${empty})
ExternalProject: Improve error when SOURCE_DIR is missing (#15560) Mention the SOURCE_DIR that we checked and found empty or missing so that the user can see the full path to what we expected to find.
2015-05-08 16:18:50 +03:00
message(SEND_ERROR
"No download info given for '${name}' and its source directory:\n"
" ${source_dir}\n"
"is not an existing non-empty directory. Please specify one of:\n"
" * SOURCE_DIR with an existing non-empty directory\n"
" * URL\n"
" * GIT_REPOSITORY\n"
" * HG_REPOSITORY\n"
" * CVS_REPOSITORY and CVS_MODULE\n"
" * SVN_REVISION\n"
" * DOWNLOAD_COMMAND"
)
Fix issue #10346. Error if SOURCE_DIR is empty. See http://public.kitware.com/Bug/view.php?id=10346. The proposed patch for the issue could not be applied as is because the SOURCE_DIR always exists for an ExternalProject_Add call by the time we get to the place to emit the potential error. The fix is to emit the error only if the source dir is empty. By which, I mean devoid of files and subdirectories. If SOURCE_DIR is used by itself, without any DOWNLOAD_COMMAND or repository info, then it implies that the SOURCE_DIR is ready to build as-is without need for a download step. Clearly, if it is empty, then it is not ready to build as is. So complain if the SOURCE_DIR is empty.
2010-06-10 02:22:58 +04:00
endif()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
endif()
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
get_property(log TARGET ${name} PROPERTY _EP_LOG_DOWNLOAD)
if(log)
set(log LOG 1)
else()
set(log "")
endif()
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
ExternalProject_Add_Step(${name} download
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
COMMENT ${comment}
COMMAND ${cmd}
WORKING_DIRECTORY ${work_dir}
DEPENDS ${depends}
DEPENDEES mkdir
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
${log}
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
function(_ep_add_update_command name)
ExternalProject: Only run 'git fetch' when required. In the current default update step for Git under the ExternalProject_Add command, a 'git fetch' is always performed, followed by a 'git checkout' and 'git submodule update --recursive'. However, a 'git fetch' can be time consuming and requires a network connection. To save time, we look at the current checked out hash, and only perform the fetch if required. This is performed in a CMake script so we can handle the conditional logic in a cross platform manner.
2012-06-09 02:29:34 +04:00
ExternalProject_Get_Property(${name} source_dir tmp_dir)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
BUG: cmd_set logic was missing from update and patch steps. Fix it so that UPDATE_COMMAND "" means "no update step even though this is a CVS/SVN repository..."
2009-07-02 21:17:55 +04:00
get_property(cmd_set TARGET ${name} PROPERTY _EP_UPDATE_COMMAND SET)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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)
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
get_property(git_repository TARGET ${name} PROPERTY _EP_GIT_REPOSITORY)
ExternalProject: Add Mercurial (hg) repository support Add options HG_REPOSITORY and HG_TAG to specify an external project hosted in a Mercurial repository. Teach ExternalProject to clone the repository and update from it. Extend the ExternalProject test to try a Mercurial repository when hg is available.
2012-08-15 18:09:43 +04:00
get_property(hg_repository TARGET ${name} PROPERTY _EP_HG_REPOSITORY )
ExternalProject: Add UPDATE_DISCONNECTED option 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.
2014-11-05 02:31:40 +03:00
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()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
set(work_dir)
set(comment)
set(always)
BUG: cmd_set logic was missing from update and patch steps. Fix it so that UPDATE_COMMAND "" means "no update step even though this is a CVS/SVN repository..."
2009-07-02 21:17:55 +04:00
if(cmd_set)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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}'")
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
get_property(svn_revision TARGET ${name} PROPERTY _EP_SVN_REVISION)
Add svn user name and password to ExternalProject. Thanks to JCFR for the leg work.
2010-05-26 22:50:19 +04:00
get_property(svn_username TARGET ${name} PROPERTY _EP_SVN_USERNAME)
get_property(svn_password TARGET ${name} PROPERTY _EP_SVN_PASSWORD)
ExternalProject: Add SVN_TRUST_CERT argument Which adds --non-interactive and --trust-server-cert to the svn checkout and update command lines. This allows ExternalProject clients to pull from an https:// based svn server even though the server may not have a valid or trusted certificate. Caveat emptor: I would NOT recommend using this except as a short-term work-around. Rather, the server should have a valid, trusted certificate, or the client should be using "http" instead of "https".
2011-04-12 00:34:58 +04:00
get_property(svn_trust_cert TARGET ${name} PROPERTY _EP_SVN_TRUST_CERT)
ExternalProject: No svn --username if empty (#11173) Nor --password. But please do if non-empty. Thank you.
2010-10-23 00:09:07 +04:00
set(svn_user_pw_args "")
ExternalProject: Allow blank SVN_USERNAME/SVN_PASSWORD (#14128) With SVN_USERNAME "" SVN_PASSWORD "" in an ExternalProject_Add() call, the blank username and password will be passed to the svn checkout/update step commands.
2013-05-06 16:30:56 +04:00
if(DEFINED svn_username)
ExternalProject: No svn --username if empty (#11173) Nor --password. But please do if non-empty. Thank you.
2010-10-23 00:09:07 +04:00
set(svn_user_pw_args ${svn_user_pw_args} "--username=${svn_username}")
endif()
ExternalProject: Allow blank SVN_USERNAME/SVN_PASSWORD (#14128) With SVN_USERNAME "" SVN_PASSWORD "" in an ExternalProject_Add() call, the blank username and password will be passed to the svn checkout/update step commands.
2013-05-06 16:30:56 +04:00
if(DEFINED svn_password)
ExternalProject: No svn --username if empty (#11173) Nor --password. But please do if non-empty. Thank you.
2010-10-23 00:09:07 +04:00
set(svn_user_pw_args ${svn_user_pw_args} "--password=${svn_password}")
endif()
ExternalProject: Add SVN_TRUST_CERT argument Which adds --non-interactive and --trust-server-cert to the svn checkout and update command lines. This allows ExternalProject clients to pull from an https:// based svn server even though the server may not have a valid or trusted certificate. Caveat emptor: I would NOT recommend using this except as a short-term work-around. Rather, the server should have a valid, trusted certificate, or the client should be using "http" instead of "https".
2011-04-12 00:34:58 +04:00
if(svn_trust_cert)
ExternalProject: Always use --non-interactive with svn The previous commit added --non-interactive as a "side effect" of turning on SVN_TRUST_CERT. While reviewing that commit, we decided all ExternalProject svn usage should be non-interactive. That way, if there's any sort of problem, svn will return an error right away rather than hang forever waiting for input...
2011-04-18 19:34:00 +04:00
set(svn_trust_cert_args --trust-server-cert)
ExternalProject: Add SVN_TRUST_CERT argument Which adds --non-interactive and --trust-server-cert to the svn checkout and update command lines. This allows ExternalProject clients to pull from an https:// based svn server even though the server may not have a valid or trusted certificate. Caveat emptor: I would NOT recommend using this except as a short-term work-around. Rather, the server should have a valid, trusted certificate, or the client should be using "http" instead of "https".
2011-04-12 00:34:58 +04:00
endif()
Add svn user name and password to ExternalProject. Thanks to JCFR for the leg work.
2010-05-26 22:50:19 +04:00
set(cmd ${Subversion_SVN_EXECUTABLE} up ${svn_revision}
ExternalProject: Always use --non-interactive with svn The previous commit added --non-interactive as a "side effect" of turning on SVN_TRUST_CERT. While reviewing that commit, we decided all ExternalProject svn usage should be non-interactive. That way, if there's any sort of problem, svn will return an error right away rather than hang forever waiting for input...
2011-04-18 19:34:00 +04:00
--non-interactive ${svn_trust_cert_args} ${svn_user_pw_args})
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
set(always 1)
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
elseif(git_repository)
Add FindGit module. Use it from ExternalProject and the ExternalProject test's CMakeLists file rather than having duplicate find_program calls. Add logic so that we do not try to use *.cmd variants of git programs when using the MSYS Makefiles generator. Should fix the last remaining dashboard issue with the new ExternalProject git support additions. Also, correct minor problem regarding placement of the local git repo during test execution. On clean builds, it was being placed incorrectly because of the ../.. relative reference. Use an absolute path to place the local git repo in the proper directory, and only use the relative reference when referring to it.
2010-06-04 01:30:07 +04:00
if(NOT GIT_EXECUTABLE)
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
message(FATAL_ERROR "error: could not find git for fetch of ${name}")
endif()
set(work_dir ${source_dir})
ExternalProject: Only run 'git fetch' when required. In the current default update step for Git under the ExternalProject_Add command, a 'git fetch' is always performed, followed by a 'git checkout' and 'git submodule update --recursive'. However, a 'git fetch' can be time consuming and requires a network connection. To save time, we look at the current checked out hash, and only perform the fetch if required. This is performed in a CMake script so we can handle the conditional logic in a cross platform manner.
2012-06-09 02:29:34 +04:00
set(comment "Performing update step for '${name}'")
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
get_property(git_tag TARGET ${name} PROPERTY _EP_GIT_TAG)
if(NOT git_tag)
set(git_tag "master")
endif()
ExternalProject: Add option GIT_SUBMODULES This option allows to filter the submodules that are checked out. Add a simple testcase for GIT_SUBMODULES option passing an empty list.
2014-01-09 18:07:10 +04:00
get_property(git_submodules TARGET ${name} PROPERTY _EP_GIT_SUBMODULES)
ExternalProject: Only run 'git fetch' when required. In the current default update step for Git under the ExternalProject_Add command, a 'git fetch' is always performed, followed by a 'git checkout' and 'git submodule update --recursive'. However, a 'git fetch' can be time consuming and requires a network connection. To save time, we look at the current checked out hash, and only perform the fetch if required. This is performed in a CMake script so we can handle the conditional logic in a cross platform manner.
2012-06-09 02:29:34 +04:00
_ep_write_gitupdate_script(${tmp_dir}/${name}-gitupdate.cmake
ExternalProject: Add option GIT_SUBMODULES This option allows to filter the submodules that are checked out. Add a simple testcase for GIT_SUBMODULES option passing an empty list.
2014-01-09 18:07:10 +04:00
${GIT_EXECUTABLE} ${git_tag} "${git_submodules}" ${git_repository} ${work_dir}
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
)
ExternalProject: Only run 'git fetch' when required. In the current default update step for Git under the ExternalProject_Add command, a 'git fetch' is always performed, followed by a 'git checkout' and 'git submodule update --recursive'. However, a 'git fetch' can be time consuming and requires a network connection. To save time, we look at the current checked out hash, and only perform the fetch if required. This is performed in a CMake script so we can handle the conditional logic in a cross platform manner.
2012-06-09 02:29:34 +04:00
set(cmd ${CMAKE_COMMAND} -P ${tmp_dir}/${name}-gitupdate.cmake)
Add git support to ExternalProject. Requires at least version 1.6.5 of a git client for git submodule update --recursive use.
2010-06-02 02:18:33 +04:00
set(always 1)
ExternalProject: Add Mercurial (hg) repository support Add options HG_REPOSITORY and HG_TAG to specify an external project hosted in a Mercurial repository. Teach ExternalProject to clone the repository and update from it. Extend the ExternalProject test to try a Mercurial repository when hg is available.
2012-08-15 18:09:43 +04:00
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)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
endif()
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
get_property(log TARGET ${name} PROPERTY _EP_LOG_UPDATE)
if(log)
set(log LOG 1)
else()
set(log "")
endif()
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
ExternalProject_Add_Step(${name} update
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
COMMENT ${comment}
COMMAND ${cmd}
ALWAYS ${always}
ExternalProject: Add UPDATE_DISCONNECTED option 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.
2014-11-05 02:31:40 +03:00
EXCLUDE_FROM_MAIN ${update_disconnected}
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
WORKING_DIRECTORY ${work_dir}
DEPENDEES download
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
${log}
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
)
ExternalProject: Add UPDATE_DISCONNECTED option 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.
2014-11-05 02:31:40 +03:00
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()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
function(_ep_add_patch_command name)
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
ExternalProject_Get_Property(${name} source_dir)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
BUG: cmd_set logic was missing from update and patch steps. Fix it so that UPDATE_COMMAND "" means "no update step even though this is a CVS/SVN repository..."
2009-07-02 21:17:55 +04:00
get_property(cmd_set TARGET ${name} PROPERTY _EP_PATCH_COMMAND SET)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
get_property(cmd TARGET ${name} PROPERTY _EP_PATCH_COMMAND)
BUG: cmd_set logic was missing from update and patch steps. Fix it so that UPDATE_COMMAND "" means "no update step even though this is a CVS/SVN repository..."
2009-07-02 21:17:55 +04:00
set(work_dir)
if(cmd_set)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
set(work_dir ${source_dir})
endif()
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
ExternalProject_Add_Step(${name} patch
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
COMMAND ${cmd}
WORKING_DIRECTORY ${work_dir}
DEPENDEES download
)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
# TODO: Make sure external projects use the proper compiler
function(_ep_add_configure_command name)
Fix issue #10258: re-configure if args change. Fixes issue http://public.kitware.com/Bug/view.php?id=10258 Also, fix complaint that DOWNLOAD_COMMAND cannot contain arguments consisting entirely of upper case letters. It validly does when, for example, you construct a custom cvs command line and the module name is all upper case, like VTK.
2010-05-26 23:38:41 +04:00
ExternalProject_Get_Property(${name} source_dir binary_dir tmp_dir)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
# Depend on other external projects (file-level).
set(file_deps)
get_property(deps TARGET ${name} PROPERTY _EP_DEPENDS)
foreach(dep IN LISTS deps)
ExternalProject: Allow dependencies on INTERFACE libraries Respect INTERFACE library property whitelist. Check that a target has type "UTILITY" before querying other properties.
2015-04-21 18:32:22 +03:00
get_property(dep_type TARGET ${dep} PROPERTY TYPE)
if(dep_type STREQUAL "UTILITY")
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()
ExternalProject: Allow DEPENDS on normal targets (#13849) The ExternalProject_Add DEPENDS option adds two types of dependencies. It adds a target-level build order dependency between the external project target and the named targets. It also adds a file-level dependency on the "done" stamp file of the named external project targets. Targets not created by ExternalProject_Add have no such stamp file and no _EP_STAMP_DIR property. Prior to commit d14c0243 (Refactor repeated code into function, 2012-04-26) we unconditionally accepted an empty stamp dir and generated a dependency on a non-existent file. After that commit we generate an error that no stamp dir is set. Skip the file-level dependency when the named dependency is not an external project target in order to allow this use case. Teach the ExternalProject test to cover the case.
2013-01-16 18:10:48 +04:00
endif()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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})
ExternalProject: Add CMAKE_CACHE_DEFAULT_ARGS arguments This argument allows to set default arguments that are written in the initial cache file, but that are not forced, and therefore allows the user to change these values later (CMAKE_ARGS and CMAKE_CACHE_ARGS always overwrite the values). Also add some documentation to explain the differences between these 3 arguments. Extend ExternalProjectLocal test to cover CMAKE_CACHE_DEFAULT_ARGS.
2014-10-28 12:52:16 +03:00
# If there are any CMAKE_CACHE_ARGS or CMAKE_CACHE_DEFAULT_ARGS,
# write an initial cache and use it
Added CMAKE_CACHE_ARGS to ExternalProject. On Windows the limit for command line arguments is 8192 characters, and this was limiting longer paths with some of our more nested projects such as Library. Placing the -D arguments into CMAKE_CACHE_ARGS will write out an initial cache file, that will be passed to CMake with a -C argument as the initial cache. By forcing the cache variables we preserve the existing behavior with -D, to change the values of cache variables in our inner projects.
2010-12-11 01:41:41 +03:00
get_property(cmake_cache_args TARGET ${name} PROPERTY _EP_CMAKE_CACHE_ARGS)
ExternalProject: Add CMAKE_CACHE_DEFAULT_ARGS arguments This argument allows to set default arguments that are written in the initial cache file, but that are not forced, and therefore allows the user to change these values later (CMAKE_ARGS and CMAKE_CACHE_ARGS always overwrite the values). Also add some documentation to explain the differences between these 3 arguments. Extend ExternalProjectLocal test to cover CMAKE_CACHE_DEFAULT_ARGS.
2014-10-28 12:52:16 +03:00
get_property(cmake_cache_default_args TARGET ${name} PROPERTY _EP_CMAKE_CACHE_DEFAULT_ARGS)
if(cmake_cache_args OR cmake_cache_default_args)
ExternalProject: Allow generator expressions in initial cache options Use file(GENERATE) to write the initial cache file so that we can evaluate generator expressions. Use a per-config initial cache file name in case the content varies by configuration.
2015-04-17 07:42:19 +03:00
set(_ep_cache_args_script "${tmp_dir}/${name}-cache-$<CONFIG>.cmake")
ExternalProject: Add CMAKE_CACHE_DEFAULT_ARGS arguments This argument allows to set default arguments that are written in the initial cache file, but that are not forced, and therefore allows the user to change these values later (CMAKE_ARGS and CMAKE_CACHE_ARGS always overwrite the values). Also add some documentation to explain the differences between these 3 arguments. Extend ExternalProjectLocal test to cover CMAKE_CACHE_DEFAULT_ARGS.
2014-10-28 12:52:16 +03:00
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}")
Added CMAKE_CACHE_ARGS to ExternalProject. On Windows the limit for command line arguments is 8192 characters, and this was limiting longer paths with some of our more nested projects such as Library. Placing the -D arguments into CMAKE_CACHE_ARGS will write out an initial cache file, that will be passed to CMake with a -C argument as the initial cache. By forcing the cache variables we preserve the existing behavior with -D, to change the values of cache variables in our inner projects.
2010-12-11 01:41:41 +03:00
list(APPEND cmd "-C${_ep_cache_args_script}")
endif()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
get_target_property(cmake_generator ${name} _EP_CMAKE_GENERATOR)
ExternalProject: Propagate the generator platform When the CMAKE_GENERATOR option is given to ExternalProject_Add, look also for option CMAKE_GENERATOR_PLATFORM to pass on to cmake as a cache definition. When no CMAKE_GENERATOR option is given explicitly then use the current project's CMAKE_GENERATOR_PLATFORM (since we already use its CMAKE_GENERATOR).
2014-09-05 23:20:47 +04:00
get_target_property(cmake_generator_platform ${name} _EP_CMAKE_GENERATOR_PLATFORM)
ExternalProject: Propagate the generator toolset When the CMAKE_GENERATOR option is given to ExternalProject_Add, look also for option CMAKE_GENERATOR_TOOLSET to select the value of the cmake "-T" command-line flag. When no CMAKE_GENERATOR option is given explicitly then use the current project's CMAKE_GENERATOR_TOOLSET (since we already use its CMAKE_GENERATOR).
2012-12-11 02:04:42 +04:00
get_target_property(cmake_generator_toolset ${name} _EP_CMAKE_GENERATOR_TOOLSET)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
if(cmake_generator)
ExternalProject: Simplify CMake command line generation Append the source directory to the command line option in a separate step instead of duplicating it with each possible generator.
2012-12-11 02:02:46 +04:00
list(APPEND cmd "-G${cmake_generator}")
ExternalProject: Propagate the generator platform When the CMAKE_GENERATOR option is given to ExternalProject_Add, look also for option CMAKE_GENERATOR_PLATFORM to pass on to cmake as a cache definition. When no CMAKE_GENERATOR option is given explicitly then use the current project's CMAKE_GENERATOR_PLATFORM (since we already use its CMAKE_GENERATOR).
2014-09-05 23:20:47 +04:00
if(cmake_generator_platform)
ExternalProject: Use -A option to pass generator platform This is less verbose than defining CMAKE_GENERATOR_PLATFORM.
2014-09-12 18:38:06 +04:00
list(APPEND cmd "-A${cmake_generator_platform}")
ExternalProject: Propagate the generator platform When the CMAKE_GENERATOR option is given to ExternalProject_Add, look also for option CMAKE_GENERATOR_PLATFORM to pass on to cmake as a cache definition. When no CMAKE_GENERATOR option is given explicitly then use the current project's CMAKE_GENERATOR_PLATFORM (since we already use its CMAKE_GENERATOR).
2014-09-05 23:20:47 +04:00
endif()
ExternalProject: Propagate the generator toolset When the CMAKE_GENERATOR option is given to ExternalProject_Add, look also for option CMAKE_GENERATOR_TOOLSET to select the value of the cmake "-T" command-line flag. When no CMAKE_GENERATOR option is given explicitly then use the current project's CMAKE_GENERATOR_TOOLSET (since we already use its CMAKE_GENERATOR).
2012-12-11 02:04:42 +04:00
if(cmake_generator_toolset)
list(APPEND cmd "-T${cmake_generator_toolset}")
endif()
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
else()
BUG 11451 - pass CMAKE_EXTRA_GENERATOR down. This patch fixes the behavior of external projects with respect to generators using the CMAKE_EXTRA_GENERATOR variable.
2010-11-13 03:43:05 +03:00
if(CMAKE_EXTRA_GENERATOR)
ExternalProject: Simplify CMake command line generation Append the source directory to the command line option in a separate step instead of duplicating it with each possible generator.
2012-12-11 02:02:46 +04:00
list(APPEND cmd "-G${CMAKE_EXTRA_GENERATOR} - ${CMAKE_GENERATOR}")
BUG 11451 - pass CMAKE_EXTRA_GENERATOR down. This patch fixes the behavior of external projects with respect to generators using the CMAKE_EXTRA_GENERATOR variable.
2010-11-13 03:43:05 +03:00
else()
ExternalProject: Simplify CMake command line generation Append the source directory to the command line option in a separate step instead of duplicating it with each possible generator.
2012-12-11 02:02:46 +04:00
list(APPEND cmd "-G${CMAKE_GENERATOR}")
BUG 11451 - pass CMAKE_EXTRA_GENERATOR down. This patch fixes the behavior of external projects with respect to generators using the CMAKE_EXTRA_GENERATOR variable.
2010-11-13 03:43:05 +03:00
endif()
ExternalProject: Propagate the generator platform When the CMAKE_GENERATOR option is given to ExternalProject_Add, look also for option CMAKE_GENERATOR_PLATFORM to pass on to cmake as a cache definition. When no CMAKE_GENERATOR option is given explicitly then use the current project's CMAKE_GENERATOR_PLATFORM (since we already use its CMAKE_GENERATOR).
2014-09-05 23:20:47 +04:00
if(cmake_generator_platform)
message(FATAL_ERROR "Option CMAKE_GENERATOR_PLATFORM not allowed without CMAKE_GENERATOR.")
endif()
if(CMAKE_GENERATOR_PLATFORM)
ExternalProject: Use -A option to pass generator platform This is less verbose than defining CMAKE_GENERATOR_PLATFORM.
2014-09-12 18:38:06 +04:00
list(APPEND cmd "-A${CMAKE_GENERATOR_PLATFORM}")
ExternalProject: Propagate the generator platform When the CMAKE_GENERATOR option is given to ExternalProject_Add, look also for option CMAKE_GENERATOR_PLATFORM to pass on to cmake as a cache definition. When no CMAKE_GENERATOR option is given explicitly then use the current project's CMAKE_GENERATOR_PLATFORM (since we already use its CMAKE_GENERATOR).
2014-09-05 23:20:47 +04:00
endif()
ExternalProject: Propagate the generator toolset When the CMAKE_GENERATOR option is given to ExternalProject_Add, look also for option CMAKE_GENERATOR_TOOLSET to select the value of the cmake "-T" command-line flag. When no CMAKE_GENERATOR option is given explicitly then use the current project's CMAKE_GENERATOR_TOOLSET (since we already use its CMAKE_GENERATOR).
2012-12-11 02:04:42 +04:00
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()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
endif()
ExternalProject: Simplify CMake command line generation Append the source directory to the command line option in a separate step instead of duplicating it with each possible generator.
2012-12-11 02:02:46 +04:00
list(APPEND cmd "${source_dir}")
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
endif()
Fix issue #10258: re-configure if args change. Fixes issue http://public.kitware.com/Bug/view.php?id=10258 Also, fix complaint that DOWNLOAD_COMMAND cannot contain arguments consisting entirely of upper case letters. It validly does when, for example, you construct a custom cvs command line and the module name is all upper case, like VTK.
2010-05-26 23:38:41 +04:00
# 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)
Escape file write expansion, and build up lists. Escaped the @var@ in the file writes - this was being expanded at file write and so not causing a reconfigure at the right time. I also took care of build up lists of lists in the variables, especially important for things like MPI_EXTRA_LIBRARY. Added some error checking, and use the tmp_dir for initial cache file.
2010-12-11 04:03:58 +03:00
file(WRITE ${tmp_dir}/${name}-cfgcmd.txt.in "cmd='\@cmd\@'\n")
Fix issue #10258: re-configure if args change. Fixes issue http://public.kitware.com/Bug/view.php?id=10258 Also, fix complaint that DOWNLOAD_COMMAND cannot contain arguments consisting entirely of upper case letters. It validly does when, for example, you construct a custom cvs command line and the module name is all upper case, like VTK.
2010-05-26 23:38:41 +04:00
endif()
configure_file(${tmp_dir}/${name}-cfgcmd.txt.in ${tmp_dir}/${name}-cfgcmd.txt)
list(APPEND file_deps ${tmp_dir}/${name}-cfgcmd.txt)
Added CMAKE_CACHE_ARGS to ExternalProject. On Windows the limit for command line arguments is 8192 characters, and this was limiting longer paths with some of our more nested projects such as Library. Placing the -D arguments into CMAKE_CACHE_ARGS will write out an initial cache file, that will be passed to CMake with a -C argument as the initial cache. By forcing the cache variables we preserve the existing behavior with -D, to change the values of cache variables in our inner projects.
2010-12-11 01:41:41 +03:00
list(APPEND file_deps ${_ep_cache_args_script})
Fix issue #10258: re-configure if args change. Fixes issue http://public.kitware.com/Bug/view.php?id=10258 Also, fix complaint that DOWNLOAD_COMMAND cannot contain arguments consisting entirely of upper case letters. It validly does when, for example, you construct a custom cvs command line and the module name is all upper case, like VTK.
2010-05-26 23:38:41 +04:00
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
get_property(log TARGET ${name} PROPERTY _EP_LOG_CONFIGURE)
if(log)
set(log LOG 1)
else()
set(log "")
endif()
ExternalProject: Add UPDATE_DISCONNECTED option 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.
2014-11-05 02:31:40 +03:00
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()
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
ExternalProject_Add_Step(${name} configure
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
COMMAND ${cmd}
WORKING_DIRECTORY ${binary_dir}
ExternalProject: Add UPDATE_DISCONNECTED option 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.
2014-11-05 02:31:40 +03:00
DEPENDEES ${update_dep} patch
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
DEPENDS ${file_deps}
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
${log}
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
function(_ep_add_build_command name)
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
ExternalProject_Get_Property(${name} binary_dir)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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()
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
get_property(log TARGET ${name} PROPERTY _EP_LOG_BUILD)
if(log)
set(log LOG 1)
else()
set(log "")
endif()
ExternalProject: Add option to always run the build step Teach ExternalProject_Add a new BUILD_ALWAYS option to skip using the build step stamp file and execute the step on every build. Extend the BuildDepends test with a case to cover this option.
2014-02-21 19:59:06 +04:00
get_property(build_always TARGET ${name} PROPERTY _EP_BUILD_ALWAYS)
if(build_always)
set(always 1)
else()
set(always 0)
endif()
ExternalProject: Add options to specify BYPRODUCTS (#14963) The external project's build process may generate byproducts on which other rules in the driving project's build later depend. Provide a way for the driving project to specify what byproducts it expects to be made available by the custom commands that drive the external project.
2014-11-14 03:26:36 +03:00
get_property(build_byproducts TARGET ${name} PROPERTY _EP_BUILD_BYPRODUCTS)
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
ExternalProject_Add_Step(${name} build
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
COMMAND ${cmd}
ExternalProject: Add options to specify BYPRODUCTS (#14963) The external project's build process may generate byproducts on which other rules in the driving project's build later depend. Provide a way for the driving project to specify what byproducts it expects to be made available by the custom commands that drive the external project.
2014-11-14 03:26:36 +03:00
BYPRODUCTS ${build_byproducts}
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
WORKING_DIRECTORY ${binary_dir}
DEPENDEES configure
ExternalProject: Add option to always run the build step Teach ExternalProject_Add a new BUILD_ALWAYS option to skip using the build step stamp file and execute the step on every build. Extend the BuildDepends test with a case to cover this option.
2014-02-21 19:59:06 +04:00
ALWAYS ${always}
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
${log}
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
function(_ep_add_install_command name)
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
ExternalProject_Get_Property(${name} binary_dir)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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()
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
get_property(log TARGET ${name} PROPERTY _EP_LOG_INSTALL)
if(log)
set(log LOG 1)
else()
set(log "")
endif()
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
ExternalProject_Add_Step(${name} install
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
COMMAND ${cmd}
WORKING_DIRECTORY ${binary_dir}
DEPENDEES build
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
${log}
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
Remove DownloadFile.cmake and UntarFile.cmake from the Modules directory. Put functionality directly into ExternalProject.cmake itself so that these modules do not end up in the upcoming release of CMake.
2009-08-19 20:19:12 +04:00
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
function(_ep_add_test_command name)
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
ExternalProject_Get_Property(${name} binary_dir)
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
get_property(before TARGET ${name} PROPERTY _EP_TEST_BEFORE_INSTALL)
get_property(after TARGET ${name} PROPERTY _EP_TEST_AFTER_INSTALL)
ExternalProject: Add TEST_EXCLUDE_FROM_MAIN option If this option is enabled, the test step is created with the EXCLUDE_FROM_MAIN option, and if TEST_BEFORE_INSTALL is enabled, the install step does not depend on the test step. This means that the test step is never executed, unless the test target is explicitly created by calling ExternalProject_Add_StepTarget, or by passing it with the STEP_TARGETS option, or with the EP_STEP_TARGETS directory property.
2014-12-01 00:28:43 +03:00
get_property(exclude TARGET ${name} PROPERTY _EP_TEST_EXCLUDE_FROM_MAIN)
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
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...)
#
ExternalProject: Add TEST_EXCLUDE_FROM_MAIN option If this option is enabled, the test step is created with the EXCLUDE_FROM_MAIN option, and if TEST_BEFORE_INSTALL is enabled, the install step does not depend on the test step. This means that the test step is never executed, unless the test target is explicitly created by calling ExternalProject_Add_StepTarget, or by passing it with the STEP_TARGETS option, or with the EP_STEP_TARGETS directory property.
2014-12-01 00:28:43 +03:00
if(cmd_set OR before OR after OR exclude)
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
if(cmd_set)
get_property(cmd TARGET ${name} PROPERTY _EP_TEST_COMMAND)
else()
_ep_get_build_command(${name} TEST cmd)
endif()
if(before)
ExternalProject: Add TEST_EXCLUDE_FROM_MAIN option If this option is enabled, the test step is created with the EXCLUDE_FROM_MAIN option, and if TEST_BEFORE_INSTALL is enabled, the install step does not depend on the test step. This means that the test step is never executed, unless the test target is explicitly created by calling ExternalProject_Add_StepTarget, or by passing it with the STEP_TARGETS option, or with the EP_STEP_TARGETS directory property.
2014-12-01 00:28:43 +03:00
set(dependees_args DEPENDEES build)
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
else()
ExternalProject: Add TEST_EXCLUDE_FROM_MAIN option If this option is enabled, the test step is created with the EXCLUDE_FROM_MAIN option, and if TEST_BEFORE_INSTALL is enabled, the install step does not depend on the test step. This means that the test step is never executed, unless the test target is explicitly created by calling ExternalProject_Add_StepTarget, or by passing it with the STEP_TARGETS option, or with the EP_STEP_TARGETS directory property.
2014-12-01 00:28:43 +03:00
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 "")
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
endif()
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
get_property(log TARGET ${name} PROPERTY _EP_LOG_TEST)
if(log)
set(log LOG 1)
else()
set(log "")
endif()
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
ExternalProject_Add_Step(${name} test
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
COMMAND ${cmd}
WORKING_DIRECTORY ${binary_dir}
ExternalProject: Add TEST_EXCLUDE_FROM_MAIN option If this option is enabled, the test step is created with the EXCLUDE_FROM_MAIN option, and if TEST_BEFORE_INSTALL is enabled, the install step does not depend on the test step. This means that the test step is never executed, unless the test target is explicitly created by calling ExternalProject_Add_StepTarget, or by passing it with the STEP_TARGETS option, or with the EP_STEP_TARGETS directory property.
2014-12-01 00:28:43 +03:00
${dependees_args}
${dependers_args}
${exclude_args}
ExternalProject: Add LOG_* options to hide step output Optionally hide the output of each external project build step by wrapping its command in a launcher script. Make output available in log files instead. This simplifies the output of external project builds.
2010-06-21 21:00:41 +04:00
${log}
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
)
endif()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
function(ExternalProject_Add name)
Eliminate ExternalProject's use of CMAKE_CFG_INTDIR subdir for Makefile generators. It was causing problems with parallel make -j invocations. Keep it for multi-configuration build systems so that Debug and Release stamp files remain separate.
2009-10-01 00:22:36 +04:00
_ep_get_configuration_subdir_suffix(cfgdir)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
# Add a custom target for the external project.
set(cmf_dir ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles)
ExternalProject: Refactor repeated code into function (#12564) Add "private/internal-use-only" function _ep_get_step_stampfile to get the name of the stamp file for a given step. The functionality provided by this commit should be identical to its parent commit.
2012-04-26 23:26:53 +04:00
set(complete_stamp_file "${cmf_dir}${cfgdir}/${name}-complete")
ExternalProject: Add EXCLUDE_FROM_ALL option to ExternalProject_Add When adding a new external project, the "all" target will depend on this. This option allows one to add an external project will not be executed when the "all" target is executed. The reason for this is that an external project could be useful, for example, only for running tests, and therefore not necessary during the build.
2013-12-06 20:09:27 +04:00
# 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.
ExternalProject: Refactor repeated code into function (#12564) Add "private/internal-use-only" function _ep_get_step_stampfile to get the name of the stamp file for a given step. The functionality provided by this commit should be identical to its parent commit.
2012-04-26 23:26:53 +04:00
add_custom_target(${name} ALL DEPENDS ${complete_stamp_file})
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
set_property(TARGET ${name} PROPERTY _EP_IS_EXTERNAL_PROJECT 1)
ExternalProject: Set LABELS property to targets This is useful for using CDash subprojects.
2014-04-07 17:42:44 +04:00
set_property(TARGET ${name} PROPERTY LABELS ${name})
ExternalProject: Set FOLDER property to targets This is useful when using the USE_FOLDERS global property
2014-04-29 13:41:12 +04:00
set_property(TARGET ${name} PROPERTY FOLDER "ExternalProjectTargets/${name}")
Use more verbose/descriptive names for the "public API" functions in the ExternalProject.cmake module. Follow the cmake function naming convention, using a ModuleFileName_ prefix. Locate stamp files under a CMAKE_CFG_INTDIR subdir of the stamp dir so that debug and release builds have separate stamp files for Visual Studio builds. If no CMAKE_GENERATOR argument is given to ExternalProject_Add, default to using the parent project's cmake generator.
2009-09-08 23:37:15 +04:00
_ep_parse_arguments(ExternalProject_Add ${name} _EP_ "${ARGN}")
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
_ep_set_directories(${name})
ExternalProject: Refactor repeated code into function (#12564) Add "private/internal-use-only" function _ep_get_step_stampfile to get the name of the stamp file for a given step. The functionality provided by this commit should be identical to its parent commit.
2012-04-26 23:26:53 +04:00
_ep_get_step_stampfile(${name} "done" done_stamp_file)
_ep_get_step_stampfile(${name} "install" install_stamp_file)
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
ExternalProject: Add EXCLUDE_FROM_ALL option to ExternalProject_Add When adding a new external project, the "all" target will depend on this. This option allows one to add an external project will not be executed when the "all" target is executed. The reason for this is that an external project could be useful, for example, only for running tests, and therefore not necessary during the build.
2013-12-06 20:09:27 +04:00
# 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()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
# 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
Ninja: Add the Ninja generator
2011-11-11 09:00:49 +04:00
# 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.
ExternalProject: Refactor repeated code into function (#12564) Add "private/internal-use-only" function _ep_get_step_stampfile to get the name of the stamp file for a given step. The functionality provided by this commit should be identical to its parent commit.
2012-04-26 23:26:53 +04:00
set(complete_outputs ${complete_stamp_file})
Ninja: Add the Ninja generator
2011-11-11 09:00:49 +04:00
if(${CMAKE_GENERATOR} MATCHES "Ninja")
ExternalProject: Refactor repeated code into function (#12564) Add "private/internal-use-only" function _ep_get_step_stampfile to get the name of the stamp file for a given step. The functionality provided by this commit should be identical to its parent commit.
2012-04-26 23:26:53 +04:00
set(complete_outputs ${complete_outputs} ${done_stamp_file})
Ninja: Add the Ninja generator
2011-11-11 09:00:49 +04:00
endif()
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
add_custom_command(
Ninja: Add the Ninja generator
2011-11-11 09:00:49 +04:00
OUTPUT ${complete_outputs}
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
COMMENT "Completed '${name}'"
Eliminate ExternalProject's use of CMAKE_CFG_INTDIR subdir for Makefile generators. It was causing problems with parallel make -j invocations. Keep it for multi-configuration build systems so that Debug and Release stamp files remain separate.
2009-10-01 00:22:36 +04:00
COMMAND ${CMAKE_COMMAND} -E make_directory ${cmf_dir}${cfgdir}
ExternalProject: Refactor repeated code into function (#12564) Add "private/internal-use-only" function _ep_get_step_stampfile to get the name of the stamp file for a given step. The functionality provided by this commit should be identical to its parent commit.
2012-04-26 23:26:53 +04:00
COMMAND ${CMAKE_COMMAND} -E touch ${complete_stamp_file}
COMMAND ${CMAKE_COMMAND} -E touch ${done_stamp_file}
DEPENDS ${install_stamp_file}
ENH: New ExternalProject.cmake module interface This creates new module ExternalProject.cmake to replace the prototype AddExternalProject.cmake module. The interface is more refined, more flexible, and better documented than the prototype. This also converts the ExternalProject test to use the new module. The old module will be removed (it was never in a CMake release) after projects using it have been converted to the new module.
2009-06-24 23:03:26 +04:00
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})
Add test step to ExternalProject builds. Rename SVN_TAG to SVN_REVISION since it is a more accurate name.
2009-09-03 20:11:14 +04:00
# Test is special in that it might depend on build, or it might depend
# on install.
#
_ep_add_test_command(${name})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()