d19b64d671
Installing large directories, e.g., the output of a doxygen run, prints one line per file resulting in too much noise in the build output. Add an option to the install(DIRECTORY) command to not print anything upon make install. Extend the RunCMake.install test with cases covering MESSAGE_NEVER behavior of the install(DIRECTORY) command. Suggested-by: Stefan Eilemann <Stefan.Eilemann@epfl.ch>
342 lines
15 KiB
ReStructuredText
342 lines
15 KiB
ReStructuredText
install
|
|
-------
|
|
|
|
.. only:: html
|
|
|
|
.. contents::
|
|
|
|
Specify rules to run at install time.
|
|
|
|
Introduction
|
|
^^^^^^^^^^^^
|
|
|
|
This command generates installation rules for a project. Rules
|
|
specified by calls to this command within a source directory are
|
|
executed in order during installation. The order across directories
|
|
is not defined.
|
|
|
|
There are multiple signatures for this command. Some of them define
|
|
installation options for files and targets. Options common to
|
|
multiple signatures are covered here but they are valid only for
|
|
signatures that specify them. The common options are:
|
|
|
|
``DESTINATION``
|
|
Specify the directory on disk to which a file will be installed.
|
|
If a full path (with a leading slash or drive letter) is given
|
|
it is used directly. If a relative path is given it is interpreted
|
|
relative to the value of the :variable:`CMAKE_INSTALL_PREFIX` variable.
|
|
The prefix can be relocated at install time using the ``DESTDIR``
|
|
mechanism explained in the :variable:`CMAKE_INSTALL_PREFIX` variable
|
|
documentation.
|
|
|
|
``PERMISSIONS``
|
|
Specify permissions for installed files. Valid permissions are
|
|
``OWNER_READ``, ``OWNER_WRITE``, ``OWNER_EXECUTE``, ``GROUP_READ``,
|
|
``GROUP_WRITE``, ``GROUP_EXECUTE``, ``WORLD_READ``, ``WORLD_WRITE``,
|
|
``WORLD_EXECUTE``, ``SETUID``, and ``SETGID``. Permissions that do
|
|
not make sense on certain platforms are ignored on those platforms.
|
|
|
|
``CONFIGURATIONS``
|
|
Specify a list of build configurations for which the install rule
|
|
applies (Debug, Release, etc.).
|
|
|
|
``COMPONENT``
|
|
Specify an installation component name with which the install rule
|
|
is associated, such as "runtime" or "development". During
|
|
component-specific installation only install rules associated with
|
|
the given component name will be executed. During a full installation
|
|
all components are installed. If ``COMPONENT`` is not provided a
|
|
default component "Unspecified" is created. The default component
|
|
name may be controlled with the
|
|
:variable:`CMAKE_INSTALL_DEFAULT_COMPONENT_NAME` variable.
|
|
|
|
``RENAME``
|
|
Specify a name for an installed file that may be different from the
|
|
original file. Renaming is allowed only when a single file is
|
|
installed by the command.
|
|
|
|
``OPTIONAL``
|
|
Specify that it is not an error if the file to be installed does
|
|
not exist.
|
|
|
|
Command signatures that install files may print messages during
|
|
installation. Use the :variable:`CMAKE_INSTALL_MESSAGE` variable
|
|
to control which messages are printed.
|
|
|
|
Installing Targets
|
|
^^^^^^^^^^^^^^^^^^
|
|
|
|
::
|
|
|
|
install(TARGETS targets... [EXPORT <export-name>]
|
|
[[ARCHIVE|LIBRARY|RUNTIME|FRAMEWORK|BUNDLE|
|
|
PRIVATE_HEADER|PUBLIC_HEADER|RESOURCE]
|
|
[DESTINATION <dir>]
|
|
[INCLUDES DESTINATION [<dir> ...]]
|
|
[PERMISSIONS permissions...]
|
|
[CONFIGURATIONS [Debug|Release|...]]
|
|
[COMPONENT <component>]
|
|
[OPTIONAL] [NAMELINK_ONLY|NAMELINK_SKIP]
|
|
] [...])
|
|
|
|
The ``TARGETS`` form specifies rules for installing targets from a
|
|
project. There are five kinds of target files that may be installed:
|
|
``ARCHIVE``, ``LIBRARY``, ``RUNTIME``, ``FRAMEWORK``, and ``BUNDLE``.
|
|
Executables are treated as ``RUNTIME`` targets, except that those
|
|
marked with the ``MACOSX_BUNDLE`` property are treated as ``BUNDLE``
|
|
targets on OS X. Static libraries are always treated as ``ARCHIVE``
|
|
targets. Module libraries are always treated as ``LIBRARY`` targets.
|
|
For non-DLL platforms shared libraries are treated as ``LIBRARY``
|
|
targets, except that those marked with the ``FRAMEWORK`` property are
|
|
treated as ``FRAMEWORK`` targets on OS X. For DLL platforms the DLL
|
|
part of a shared library is treated as a ``RUNTIME`` target and the
|
|
corresponding import library is treated as an ``ARCHIVE`` target.
|
|
All Windows-based systems including Cygwin are DLL platforms.
|
|
The ``ARCHIVE``, ``LIBRARY``, ``RUNTIME``, and ``FRAMEWORK`` arguments
|
|
change the type of target to which the subsequent properties apply.
|
|
If none is given the installation properties apply to all target
|
|
types. If only one is given then only targets of that type will be
|
|
installed (which can be used to install just a DLL or just an import
|
|
library). The ``INCLUDES DESTINATION`` specifies a list of directories
|
|
which will be added to the :prop_tgt:`INTERFACE_INCLUDE_DIRECTORIES`
|
|
target property of the ``<targets>`` when exported by the
|
|
:command:`install(EXPORT)` command. If a relative path is
|
|
specified, it is treated as relative to the ``$<INSTALL_PREFIX>``.
|
|
|
|
The ``PRIVATE_HEADER``, ``PUBLIC_HEADER``, and ``RESOURCE`` arguments
|
|
cause subsequent properties to be applied to installing a ``FRAMEWORK``
|
|
shared library target's associated files on non-Apple platforms. Rules
|
|
defined by these arguments are ignored on Apple platforms because the
|
|
associated files are installed into the appropriate locations inside
|
|
the framework folder. See documentation of the
|
|
:prop_tgt:`PRIVATE_HEADER`, :prop_tgt:`PUBLIC_HEADER`, and
|
|
:prop_tgt:`RESOURCE` target properties for details.
|
|
|
|
Either ``NAMELINK_ONLY`` or ``NAMELINK_SKIP`` may be specified as a
|
|
``LIBRARY`` option. On some platforms a versioned shared library
|
|
has a symbolic link such as::
|
|
|
|
lib<name>.so -> lib<name>.so.1
|
|
|
|
where ``lib<name>.so.1`` is the soname of the library and ``lib<name>.so``
|
|
is a "namelink" allowing linkers to find the library when given
|
|
``-l<name>``. The ``NAMELINK_ONLY`` option causes installation of only the
|
|
namelink when a library target is installed. The ``NAMELINK_SKIP`` option
|
|
causes installation of library files other than the namelink when a
|
|
library target is installed. When neither option is given both
|
|
portions are installed. On platforms where versioned shared libraries
|
|
do not have namelinks or when a library is not versioned the
|
|
``NAMELINK_SKIP`` option installs the library and the ``NAMELINK_ONLY``
|
|
option installs nothing. See the :prop_tgt:`VERSION` and
|
|
:prop_tgt:`SOVERSION` target properties for details on creating versioned
|
|
shared libraries.
|
|
|
|
One or more groups of properties may be specified in a single call to
|
|
the ``TARGETS`` form of this command. A target may be installed more than
|
|
once to different locations. Consider hypothetical targets ``myExe``,
|
|
``mySharedLib``, and ``myStaticLib``. The code:
|
|
|
|
.. code-block:: cmake
|
|
|
|
install(TARGETS myExe mySharedLib myStaticLib
|
|
RUNTIME DESTINATION bin
|
|
LIBRARY DESTINATION lib
|
|
ARCHIVE DESTINATION lib/static)
|
|
install(TARGETS mySharedLib DESTINATION /some/full/path)
|
|
|
|
will install ``myExe`` to ``<prefix>/bin`` and ``myStaticLib`` to
|
|
``<prefix>/lib/static``. On non-DLL platforms ``mySharedLib`` will be
|
|
installed to ``<prefix>/lib`` and ``/some/full/path``. On DLL platforms
|
|
the ``mySharedLib`` DLL will be installed to ``<prefix>/bin`` and
|
|
``/some/full/path`` and its import library will be installed to
|
|
``<prefix>/lib/static`` and ``/some/full/path``.
|
|
|
|
The ``EXPORT`` option associates the installed target files with an
|
|
export called ``<export-name>``. It must appear before any ``RUNTIME``,
|
|
``LIBRARY``, or ``ARCHIVE`` options. To actually install the export
|
|
file itself, call ``install(EXPORT)``, documented below.
|
|
|
|
Installing a target with the :prop_tgt:`EXCLUDE_FROM_ALL` target property
|
|
set to ``TRUE`` has undefined behavior.
|
|
|
|
Installing Files
|
|
^^^^^^^^^^^^^^^^
|
|
|
|
::
|
|
|
|
install(<FILES|PROGRAMS> files... DESTINATION <dir>
|
|
[PERMISSIONS permissions...]
|
|
[CONFIGURATIONS [Debug|Release|...]]
|
|
[COMPONENT <component>]
|
|
[RENAME <name>] [OPTIONAL])
|
|
|
|
The ``FILES`` form specifies rules for installing files for a project.
|
|
File names given as relative paths are interpreted with respect to the
|
|
current source directory. Files installed by this form are by default
|
|
given permissions ``OWNER_WRITE``, ``OWNER_READ``, ``GROUP_READ``, and
|
|
``WORLD_READ`` if no ``PERMISSIONS`` argument is given.
|
|
|
|
The ``PROGRAMS`` form is identical to the ``FILES`` form except that the
|
|
default permissions for the installed file also include ``OWNER_EXECUTE``,
|
|
``GROUP_EXECUTE``, and ``WORLD_EXECUTE``. This form is intended to install
|
|
programs that are not targets, such as shell scripts. Use the ``TARGETS``
|
|
form to install targets built within the project.
|
|
|
|
The list of ``files...`` given to ``FILES`` or ``PROGRAMS`` may use
|
|
"generator expressions" with the syntax ``$<...>``. See the
|
|
:manual:`cmake-generator-expressions(7)` manual for available expressions.
|
|
However, if any item begins in a generator expression it must evaluate
|
|
to a full path.
|
|
|
|
Installing Directories
|
|
^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
::
|
|
|
|
install(DIRECTORY dirs... DESTINATION <dir>
|
|
[FILE_PERMISSIONS permissions...]
|
|
[DIRECTORY_PERMISSIONS permissions...]
|
|
[USE_SOURCE_PERMISSIONS] [OPTIONAL] [MESSAGE_NEVER]
|
|
[CONFIGURATIONS [Debug|Release|...]]
|
|
[COMPONENT <component>] [FILES_MATCHING]
|
|
[[PATTERN <pattern> | REGEX <regex>]
|
|
[EXCLUDE] [PERMISSIONS permissions...]] [...])
|
|
|
|
The ``DIRECTORY`` form installs contents of one or more directories to a
|
|
given destination. The directory structure is copied verbatim to the
|
|
destination. The last component of each directory name is appended to
|
|
the destination directory but a trailing slash may be used to avoid
|
|
this because it leaves the last component empty. Directory names
|
|
given as relative paths are interpreted with respect to the current
|
|
source directory. If no input directory names are given the
|
|
destination directory will be created but nothing will be installed
|
|
into it. The ``FILE_PERMISSIONS`` and ``DIRECTORY_PERMISSIONS`` options
|
|
specify permissions given to files and directories in the destination.
|
|
If ``USE_SOURCE_PERMISSIONS`` is specified and ``FILE_PERMISSIONS`` is not,
|
|
file permissions will be copied from the source directory structure.
|
|
If no permissions are specified files will be given the default
|
|
permissions specified in the ``FILES`` form of the command, and the
|
|
directories will be given the default permissions specified in the
|
|
``PROGRAMS`` form of the command.
|
|
|
|
The ``MESSAGE_NEVER`` option disables file installation status output.
|
|
|
|
Installation of directories may be controlled with fine granularity
|
|
using the ``PATTERN`` or ``REGEX`` options. These "match" options specify a
|
|
globbing pattern or regular expression to match directories or files
|
|
encountered within input directories. They may be used to apply
|
|
certain options (see below) to a subset of the files and directories
|
|
encountered. The full path to each input file or directory (with
|
|
forward slashes) is matched against the expression. A ``PATTERN`` will
|
|
match only complete file names: the portion of the full path matching
|
|
the pattern must occur at the end of the file name and be preceded by
|
|
a slash. A ``REGEX`` will match any portion of the full path but it may
|
|
use ``/`` and ``$`` to simulate the ``PATTERN`` behavior. By default all
|
|
files and directories are installed whether or not they are matched.
|
|
The ``FILES_MATCHING`` option may be given before the first match option
|
|
to disable installation of files (but not directories) not matched by
|
|
any expression. For example, the code
|
|
|
|
.. code-block:: cmake
|
|
|
|
install(DIRECTORY src/ DESTINATION include/myproj
|
|
FILES_MATCHING PATTERN "*.h")
|
|
|
|
will extract and install header files from a source tree.
|
|
|
|
Some options may follow a ``PATTERN`` or ``REGEX`` expression and are applied
|
|
only to files or directories matching them. The ``EXCLUDE`` option will
|
|
skip the matched file or directory. The ``PERMISSIONS`` option overrides
|
|
the permissions setting for the matched file or directory. For
|
|
example the code
|
|
|
|
.. code-block:: cmake
|
|
|
|
install(DIRECTORY icons scripts/ DESTINATION share/myproj
|
|
PATTERN "CVS" EXCLUDE
|
|
PATTERN "scripts/*"
|
|
PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ
|
|
GROUP_EXECUTE GROUP_READ)
|
|
|
|
will install the ``icons`` directory to ``share/myproj/icons`` and the
|
|
``scripts`` directory to ``share/myproj``. The icons will get default
|
|
file permissions, the scripts will be given specific permissions, and any
|
|
``CVS`` directories will be excluded.
|
|
|
|
Custom Installation Logic
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
::
|
|
|
|
install([[SCRIPT <file>] [CODE <code>]] [...])
|
|
|
|
The ``SCRIPT`` form will invoke the given CMake script files during
|
|
installation. If the script file name is a relative path it will be
|
|
interpreted with respect to the current source directory. The ``CODE``
|
|
form will invoke the given CMake code during installation. Code is
|
|
specified as a single argument inside a double-quoted string. For
|
|
example, the code
|
|
|
|
.. code-block:: cmake
|
|
|
|
install(CODE "MESSAGE(\"Sample install message.\")")
|
|
|
|
will print a message during installation.
|
|
|
|
Installing Exports
|
|
^^^^^^^^^^^^^^^^^^
|
|
|
|
::
|
|
|
|
install(EXPORT <export-name> DESTINATION <dir>
|
|
[NAMESPACE <namespace>] [FILE <name>.cmake]
|
|
[PERMISSIONS permissions...]
|
|
[CONFIGURATIONS [Debug|Release|...]]
|
|
[EXPORT_LINK_INTERFACE_LIBRARIES]
|
|
[COMPONENT <component>])
|
|
|
|
The ``EXPORT`` form generates and installs a CMake file containing code to
|
|
import targets from the installation tree into another project.
|
|
Target installations are associated with the export ``<export-name>``
|
|
using the ``EXPORT`` option of the ``install(TARGETS)`` signature
|
|
documented above. The ``NAMESPACE`` option will prepend ``<namespace>`` to
|
|
the target names as they are written to the import file. By default
|
|
the generated file will be called ``<export-name>.cmake`` but the ``FILE``
|
|
option may be used to specify a different name. The value given to
|
|
the ``FILE`` option must be a file name with the ``.cmake`` extension.
|
|
If a ``CONFIGURATIONS`` option is given then the file will only be installed
|
|
when one of the named configurations is installed. Additionally, the
|
|
generated import file will reference only the matching target
|
|
configurations. The ``EXPORT_LINK_INTERFACE_LIBRARIES`` keyword, if
|
|
present, causes the contents of the properties matching
|
|
``(IMPORTED_)?LINK_INTERFACE_LIBRARIES(_<CONFIG>)?`` to be exported, when
|
|
policy :policy:`CMP0022` is ``NEW``. If a ``COMPONENT`` option is
|
|
specified that does not match that given to the targets associated with
|
|
``<export-name>`` the behavior is undefined. If a library target is
|
|
included in the export but a target to which it links is not included
|
|
the behavior is unspecified.
|
|
|
|
The ``EXPORT`` form is useful to help outside projects use targets built
|
|
and installed by the current project. For example, the code
|
|
|
|
.. code-block:: cmake
|
|
|
|
install(TARGETS myexe EXPORT myproj DESTINATION bin)
|
|
install(EXPORT myproj NAMESPACE mp_ DESTINATION lib/myproj)
|
|
|
|
will install the executable myexe to ``<prefix>/bin`` and code to import
|
|
it in the file ``<prefix>/lib/myproj/myproj.cmake``. An outside project
|
|
may load this file with the include command and reference the ``myexe``
|
|
executable from the installation tree using the imported target name
|
|
``mp_myexe`` as if the target were built in its own tree.
|
|
|
|
.. note::
|
|
This command supercedes the :command:`install_targets` command and
|
|
the :prop_tgt:`PRE_INSTALL_SCRIPT` and :prop_tgt:`POST_INSTALL_SCRIPT`
|
|
target properties. It also replaces the ``FILES`` forms of the
|
|
:command:`install_files` and :command:`install_programs` commands.
|
|
The processing order of these install rules relative to
|
|
those generated by :command:`install_targets`,
|
|
:command:`install_files`, and :command:`install_programs` commands
|
|
is not defined.
|