Merge branch 'install-FILES-genex' into release

Help/command/install.rst

@@ -9,43 +9,50 @@ executed in order during installation.  The order across directories
 is not defined.
 
 There are multiple signatures for this command.  Some of them define
-installation properties for files and targets.  Properties common to
+installation options for files and targets.  Options common to
 multiple signatures are covered here but they are valid only for
-signatures that specify them.
+signatures that specify them.  The common options are:
 
-DESTINATION arguments specify the directory on disk to which a file
+``DESTINATION``
-will be installed.  If a full path (with a leading slash or drive
+  Specify the directory on disk to which a file will be installed.
-letter) is given it is used directly.  If a relative path is given it
+  If a full path (with a leading slash or drive letter) is given
-is interpreted relative to the value of CMAKE_INSTALL_PREFIX.  The
+  it is used directly.  If a relative path is given it is interpreted
-prefix can be relocated at install time using DESTDIR mechanism
+  relative to the value of the :variable:`CMAKE_INSTALL_PREFIX` variable.
-explained in the CMAKE_INSTALL_PREFIX variable documentation.
+  The prefix can be relocated at install time using the ``DESTDIR``
+  mechanism explained in the :variable:`CMAKE_INSTALL_PREFIX` variable
+  documentation.
 
-PERMISSIONS arguments specify permissions for installed files.  Valid
+``PERMISSIONS``
-permissions are OWNER_READ, OWNER_WRITE, OWNER_EXECUTE, GROUP_READ,
+  Specify permissions for installed files.  Valid permissions are
-GROUP_WRITE, GROUP_EXECUTE, WORLD_READ, WORLD_WRITE, WORLD_EXECUTE,
+  ``OWNER_READ``, ``OWNER_WRITE``, ``OWNER_EXECUTE``, ``GROUP_READ``,
-SETUID, and SETGID.  Permissions that do not make sense on certain
+  ``GROUP_WRITE``, ``GROUP_EXECUTE``, ``WORLD_READ``, ``WORLD_WRITE``,
-platforms are ignored on those platforms.
+  ``WORLD_EXECUTE``, ``SETUID``, and ``SETGID``.  Permissions that do
+  not make sense on certain platforms are ignored on those platforms.
 
-The CONFIGURATIONS argument specifies a list of build configurations
+``CONFIGURATIONS``
-for which the install rule applies (Debug, Release, etc.).
+  Specify a list of build configurations for which the install rule
+  applies (Debug, Release, etc.).
 
-The COMPONENT argument specifies an installation component name with
+``COMPONENT``
-which the install rule is associated, such as "runtime" or
+  Specify an installation component name with which the install rule
-"development".  During component-specific installation only install
+  is associated, such as "runtime" or "development".  During
-rules associated with the given component name will be executed.
+  component-specific installation only install rules associated with
-During a full installation all components are installed.  If COMPONENT
+  the given component name will be executed.  During a full installation
-is not provided a default component "Unspecified" is created.  The
+  all components are installed.  If ``COMPONENT`` is not provided a
-default component name may be controlled with the
+  default component "Unspecified" is created.  The default component
-CMAKE_INSTALL_DEFAULT_COMPONENT_NAME variable.
+  name may be controlled with the
+  :variable:`CMAKE_INSTALL_DEFAULT_COMPONENT_NAME` variable.
 
-The RENAME argument specifies a name for an installed file that may be
+``RENAME``
-different from the original file.  Renaming is allowed only when a
+  Specify a name for an installed file that may be different from the
-single file is installed by the command.
+  original file.  Renaming is allowed only when a single file is
+  installed by the command.
 
-The OPTIONAL argument specifies that it is not an error if the file to
+``OPTIONAL``
-be installed does not exist.
+  Specify that it is not an error if the file to be installed does
+  not exist.
 
-The TARGETS signature:
+------------------------------------------------------------------------------
 
 ::
 
@@ -60,118 +67,115 @@ The TARGETS signature:
            [OPTIONAL] [NAMELINK_ONLY|NAMELINK_SKIP]
           ] [...])
 
-The TARGETS form specifies rules for installing targets from a
+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
+``ARCHIVE``, ``LIBRARY``, ``RUNTIME``, ``FRAMEWORK``, and ``BUNDLE``.
-treated as RUNTIME targets, except that those marked with the
+Executables are treated as ``RUNTIME`` targets, except that those
-MACOSX_BUNDLE property are treated as BUNDLE targets on OS X.  Static
+marked with the ``MACOSX_BUNDLE`` property are treated as ``BUNDLE``
-libraries are always treated as ARCHIVE targets.  Module libraries are
+targets on OS X.  Static libraries are always treated as ``ARCHIVE``
-always treated as LIBRARY targets.  For non-DLL platforms shared
+targets.  Module libraries are always treated as ``LIBRARY`` targets.
-libraries are treated as LIBRARY targets, except that those marked
+For non-DLL platforms shared libraries are treated as ``LIBRARY``
-with the FRAMEWORK property are treated as FRAMEWORK targets on OS X.
+targets, except that those marked with the ``FRAMEWORK`` property are
-For DLL platforms the DLL part of a shared library is treated as a
+treated as ``FRAMEWORK`` targets on OS X.  For DLL platforms the DLL
-RUNTIME target and the corresponding import library is treated as an
+part of a shared library is treated as a ``RUNTIME`` target and the
-ARCHIVE target.  All Windows-based systems including Cygwin are DLL
+corresponding import library is treated as an ``ARCHIVE`` target.
-platforms.  The ARCHIVE, LIBRARY, RUNTIME, and FRAMEWORK arguments
+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
+library).  The ``INCLUDES DESTINATION`` specifies a list of directories
-which will be added to the INTERFACE_INCLUDE_DIRECTORIES of the
+which will be added to the :prop_tgt:`INTERFACE_INCLUDE_DIRECTORIES`
-<targets> when exported by install(EXPORT).  If a relative path is
+target property of the ``<targets>`` when exported by the
-specified, it is treated as relative to the $<INSTALL_PREFIX>.
+: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
+The ``PRIVATE_HEADER``, ``PUBLIC_HEADER``, and ``RESOURCE`` arguments
-subsequent properties to be applied to installing a FRAMEWORK shared
+cause subsequent properties to be applied to installing a ``FRAMEWORK``
-library target's associated files on non-Apple platforms.  Rules
+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 PRIVATE_HEADER,
+the framework folder.  See documentation of the
-PUBLIC_HEADER, and RESOURCE target properties for details.
+: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
+Either ``NAMELINK_ONLY`` or ``NAMELINK_SKIP`` may be specified as a
-option.  On some platforms a versioned shared library has a symbolic
+``LIBRARY`` option.  On some platforms a versioned shared library
-link such as
+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"
+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
+``-l<name>``.  The ``NAMELINK_ONLY`` option causes installation of only the
-namelink when a library target is installed.  The NAMELINK_SKIP option
+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
+``NAMELINK_SKIP`` option installs the library and the ``NAMELINK_ONLY``
-installs nothing.  See the VERSION and SOVERSION target properties for
+option installs nothing.  See the :prop_tgt:`VERSION` and
-details on creating versioned shared libraries.
+: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
+the ``TARGETS`` form of this command.  A target may be installed more than
-once to different locations.  Consider hypothetical targets "myExe",
+once to different locations.  Consider hypothetical targets ``myExe``,
-"mySharedLib", and "myStaticLib".  The code
+``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.
+
+------------------------------------------------------------------------------
 
 ::
 
-    install(TARGETS myExe mySharedLib myStaticLib
+  install(<FILES|PROGRAMS> files... DESTINATION <dir>
-            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).  See documentation of the install(EXPORT ...)
-signature below for details.
-
-Installing a target with EXCLUDE_FROM_ALL set to true has undefined
-behavior.
-
-The FILES signature:
-
-::
-
-  install(FILES files... DESTINATION <dir>
           [PERMISSIONS permissions...]
           [CONFIGURATIONS [Debug|Release|...]]
           [COMPONENT <component>]
           [RENAME <name>] [OPTIONAL])
 
-The FILES form specifies rules for installing files for a project.
+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
+given permissions ``OWNER_WRITE``, ``OWNER_READ``, ``GROUP_READ``, and
-if no PERMISSIONS argument is given.
+``WORLD_READ`` if no ``PERMISSIONS`` argument is given.
 
-The PROGRAMS signature:
+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``
-  install(PROGRAMS files... DESTINATION <dir>
-          [PERMISSIONS permissions...]
-          [CONFIGURATIONS [Debug|Release|...]]
-          [COMPONENT <component>]
-          [RENAME <name>] [OPTIONAL])
-
-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 DIRECTORY signature:
+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.
+
+------------------------------------------------------------------------------
 
 ::
 
@@ -184,7 +188,7 @@ The DIRECTORY signature:
           [[PATTERN <pattern> | REGEX <regex>]
            [EXCLUDE] [PERMISSIONS permissions...]] [...])
 
-The DIRECTORY form installs contents of one or more directories to a
+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
@@ -192,45 +196,45 @@ 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
+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,
+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
+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.
+``PROGRAMS`` form of the command.
 
 Installation of directories may be controlled with fine granularity
-using the PATTERN or REGEX options.  These "match" options specify a
+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
+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
+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
+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
+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
+Some options may follow a ``PATTERN`` or ``REGEX`` expression and are applied
-only to files or directories matching them.  The EXCLUDE option will
+only to files or directories matching them.  The ``EXCLUDE`` option will
-skip the matched file or directory.  The PERMISSIONS option overrides
+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
@@ -238,31 +242,31 @@ example the code
           PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ
                       GROUP_EXECUTE GROUP_READ)
 
-will install the icons directory to share/myproj/icons and the scripts
+will install the ``icons`` directory to ``share/myproj/icons`` and the
-directory to share/myproj.  The icons will get default file
+``scripts`` directory to ``share/myproj``.  The icons will get default
-permissions, the scripts will be given specific permissions, and any
+file permissions, the scripts will be given specific permissions, and any
-CVS directories will be excluded.
+``CVS`` directories will be excluded.
 
-The SCRIPT and CODE signature:
+------------------------------------------------------------------------------
 
 ::
 
   install([[SCRIPT <file>] [CODE <code>]] [...])
 
-The SCRIPT form will invoke the given CMake script files during
+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
+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.
 
-The EXPORT signature:
+------------------------------------------------------------------------------
 
 ::
 
@@ -273,44 +277,47 @@ The EXPORT signature:
           [EXPORT_LINK_INTERFACE_LIBRARIES]
           [COMPONENT <component>])
 
-The EXPORT form generates and installs a CMake file containing code to
+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>
+Target installations are associated with the export ``<export-name>``
-using the EXPORT option of the install(TARGETS ...) signature
+using the ``EXPORT`` option of the ``install(TARGETS)`` signature
-documented above.  The NAMESPACE option will prepend <namespace> to
+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
+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
+the ``FILE`` option must be a file name with the ``.cmake`` extension.
-CONFIGURATIONS option is given then the file will only be installed
+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
+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 CMP0022 is NEW.  If a COMPONENT option is specified that does
+policy :policy:`CMP0022` is ``NEW``.  If a ``COMPONENT`` option is
-not match that given to the targets associated with <export-name> the
+specified that does not match that given to the targets associated with
-behavior is undefined.  If a library target is included in the export
+``<export-name>`` the behavior is undefined.  If a library target is
-but a target to which it links is not included the behavior is
+included in the export but a target to which it links is not included
-unspecified.
+the behavior is unspecified.
 
-The EXPORT form is useful to help outside projects use targets built
+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
+will install the executable myexe to ``<prefix>/bin`` and code to import
-it in the file "<prefix>/lib/myproj/myproj.cmake".  An outside project
+it in the file ``<prefix>/lib/myproj/myproj.cmake``.  An outside project
-may load this file with the include command and reference the myexe
+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.
+``mp_myexe`` as if the target were built in its own tree.
 
-NOTE: This command supercedes the INSTALL_TARGETS command and the
+.. note::
-target properties PRE_INSTALL_SCRIPT and POST_INSTALL_SCRIPT.  It also
+  This command supercedes the :command:`install_targets` command and
-replaces the FILES forms of the INSTALL_FILES and INSTALL_PROGRAMS
+  the :prop_tgt:`PRE_INSTALL_SCRIPT` and :prop_tgt:`POST_INSTALL_SCRIPT`
-commands.  The processing order of these install rules relative to
+  target properties.  It also replaces the ``FILES`` forms of the
-those generated by INSTALL_TARGETS, INSTALL_FILES, and
+  :command:`install_files` and :command:`install_programs` commands.
-INSTALL_PROGRAMS commands is not defined.
+  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.

Help/release/3.0.0.rst

@@ -102,6 +102,10 @@ Commands
   configuration because it will not be available.
   Use :ref:`Alias Targets` instead.  See policy :policy:`CMP0024`.
 
+* The :command:`install(FILES)` command learned to support
+  :manual:`generator expressions <cmake-generator-expressions(7)>`
+  in the list of files.
+
 * The :command:`project` command learned to set some version variables
   to values specified by the new ``VERSION`` option or to empty strings.
   See policy :policy:`CMP0048`.

Source/cmInstallCommand.cxx

@@ -32,10 +32,12 @@ static cmInstallTargetGenerator* CreateInstallTargetGenerator(cmTarget& target,
 }
 
 static cmInstallFilesGenerator* CreateInstallFilesGenerator(
+  cmMakefile* mf,
     const std::vector<std::string>& absFiles,
     const cmInstallCommandArguments& args, bool programs)
 {
-  return new cmInstallFilesGenerator(absFiles, args.GetDestination().c_str(),
+  return new cmInstallFilesGenerator(mf,
+                        absFiles, args.GetDestination().c_str(),
                         programs, args.GetPermissions().c_str(),
                         args.GetConfigurations(), args.GetComponent().c_str(),
                         args.GetRename().c_str(), args.GetOptional());
@@ -668,7 +670,8 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
         if (!privateHeaderArgs.GetDestination().empty())
           {
           privateHeaderGenerator =
-            CreateInstallFilesGenerator(absFiles, privateHeaderArgs, false);
+            CreateInstallFilesGenerator(this->Makefile, absFiles,
+                                        privateHeaderArgs, false);
           }
         else
           {
@@ -694,7 +697,8 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
         if (!publicHeaderArgs.GetDestination().empty())
           {
           publicHeaderGenerator =
-            CreateInstallFilesGenerator(absFiles, publicHeaderArgs, false);
+            CreateInstallFilesGenerator(this->Makefile, absFiles,
+                                        publicHeaderArgs, false);
           }
         else
           {
@@ -719,8 +723,8 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
         // Create the files install generator.
         if (!resourceArgs.GetDestination().empty())
           {
-          resourceGenerator = CreateInstallFilesGenerator(absFiles,
+          resourceGenerator = CreateInstallFilesGenerator(
-                                                          resourceArgs, false);
+            this->Makefile, absFiles, resourceArgs, false);
           }
         else
           {
@@ -888,7 +892,7 @@ bool cmInstallCommand::HandleFilesMode(std::vector<std::string> const& args)
 
   // Create the files install generator.
   this->Makefile->AddInstallGenerator(
-                         CreateInstallFilesGenerator(absFiles, ica, programs));
+    CreateInstallFilesGenerator(this->Makefile, absFiles, ica, programs));
 
   //Tell the global generator about any installation component names specified.
   this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
@@ -1351,7 +1355,8 @@ bool cmInstallCommand::MakeFilesFullPath(const char* modeName,
       ++fileIt)
     {
     std::string file = (*fileIt);
-    if(!cmSystemTools::FileIsFullPath(file.c_str()))
+    std::string::size_type gpos = cmGeneratorExpression::Find(file);
+    if(gpos != 0 && !cmSystemTools::FileIsFullPath(file.c_str()))
       {
       file = this->Makefile->GetCurrentDirectory();
       file += "/";
@@ -1359,7 +1364,7 @@ bool cmInstallCommand::MakeFilesFullPath(const char* modeName,
       }
 
     // Make sure the file is not a directory.
-    if(cmSystemTools::FileIsDirectory(file.c_str()))
+    if(gpos == file.npos && cmSystemTools::FileIsDirectory(file.c_str()))
       {
       cmOStringStream e;
       e << modeName << " given directory \"" << (*fileIt) << "\" to install.";

Source/cmInstallFilesCommand.cxx

@@ -133,7 +133,7 @@ void cmInstallFilesCommand::CreateInstallGenerator() const
                                        "CMAKE_INSTALL_DEFAULT_COMPONENT_NAME");
   std::vector<std::string> no_configurations;
   this->Makefile->AddInstallGenerator(
-    new cmInstallFilesGenerator(this->Files,
+    new cmInstallFilesGenerator(this->Makefile, this->Files,
                                 destination.c_str(), false,
                                 no_permissions, no_configurations,
                                 no_component.c_str(), no_rename));
@@ -148,7 +148,8 @@ void cmInstallFilesCommand::CreateInstallGenerator() const
  */
 std::string cmInstallFilesCommand::FindInstallSource(const char* name) const
 {
-  if(cmSystemTools::FileIsFullPath(name))
+  if(cmSystemTools::FileIsFullPath(name) ||
+     cmGeneratorExpression::Find(name) == 0)
     {
     // This is a full path.
     return name;

Source/cmInstallFilesGenerator.cxx

@@ -11,9 +11,13 @@
 ============================================================================*/
 #include "cmInstallFilesGenerator.h"
 
+#include "cmGeneratorExpression.h"
+#include "cmSystemTools.h"
+
 //----------------------------------------------------------------------------
 cmInstallFilesGenerator
-::cmInstallFilesGenerator(std::vector<std::string> const& files,
+::cmInstallFilesGenerator(cmMakefile* mf,
+                          std::vector<std::string> const& files,
                           const char* dest, bool programs,
                           const char* file_permissions,
                           std::vector<std::string> const& configurations,
@@ -21,10 +25,20 @@ cmInstallFilesGenerator
                           const char* rename,
                           bool optional):
   cmInstallGenerator(dest, configurations, component),
+  Makefile(mf),
   Files(files), Programs(programs),
   FilePermissions(file_permissions),
   Rename(rename), Optional(optional)
 {
+  // We need per-config actions if any files have generator expressions.
+  for(std::vector<std::string>::const_iterator i = files.begin();
+      !this->ActionsPerConfig && i != files.end(); ++i)
+    {
+    if(cmGeneratorExpression::Find(*i) != std::string::npos)
+      {
+      this->ActionsPerConfig = true;
+      }
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -34,8 +48,9 @@ cmInstallFilesGenerator
 }
 
 //----------------------------------------------------------------------------
-void cmInstallFilesGenerator::GenerateScriptActions(std::ostream& os,
+void cmInstallFilesGenerator::AddFilesInstallRule(
-                                                    Indent const& indent)
+  std::ostream& os, Indent const& indent,
+  std::vector<std::string> const& files)
 {
   // Write code to install the files.
   const char* no_dir_permissions = 0;
@@ -43,8 +58,40 @@ void cmInstallFilesGenerator::GenerateScriptActions(std::ostream& os,
                        (this->Programs
                         ? cmInstallType_PROGRAMS
                         : cmInstallType_FILES),
-                       this->Files,
+                       files,
                        this->Optional,
                        this->FilePermissions.c_str(), no_dir_permissions,
                        this->Rename.c_str(), 0, indent);
 }
+
+//----------------------------------------------------------------------------
+void cmInstallFilesGenerator::GenerateScriptActions(std::ostream& os,
+                                                    Indent const& indent)
+{
+  if(this->ActionsPerConfig)
+    {
+    this->cmInstallGenerator::GenerateScriptActions(os, indent);
+    }
+  else
+    {
+    this->AddFilesInstallRule(os, indent, this->Files);
+    }
+}
+
+//----------------------------------------------------------------------------
+void cmInstallFilesGenerator::GenerateScriptForConfig(std::ostream& os,
+                                                      const char* config,
+                                                      Indent const& indent)
+{
+  std::vector<std::string> files;
+  cmListFileBacktrace lfbt;
+  cmGeneratorExpression ge(lfbt);
+  for(std::vector<std::string>::const_iterator i = this->Files.begin();
+      i != this->Files.end(); ++i)
+    {
+    cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(*i);
+    cmSystemTools::ExpandListArgument(cge->Evaluate(this->Makefile, config),
+                                      files);
+    }
+  this->AddFilesInstallRule(os, indent, files);
+}

Source/cmInstallFilesGenerator.h

@@ -14,13 +14,16 @@
 
 #include "cmInstallGenerator.h"
 
+class cmMakefile;
+
 /** \class cmInstallFilesGenerator
  * \brief Generate file installation rules.
  */
 class cmInstallFilesGenerator: public cmInstallGenerator
 {
 public:
-  cmInstallFilesGenerator(std::vector<std::string> const& files,
+  cmInstallFilesGenerator(cmMakefile* mf,
+                          std::vector<std::string> const& files,
                           const char* dest, bool programs,
                           const char* file_permissions,
                           std::vector<std::string> const& configurations,
@@ -31,6 +34,13 @@ public:
 
 protected:
   virtual void GenerateScriptActions(std::ostream& os, Indent const& indent);
+  virtual void GenerateScriptForConfig(std::ostream& os,
+                                       const char* config,
+                                       Indent const& indent);
+  void AddFilesInstallRule(std::ostream& os, Indent const& indent,
+                           std::vector<std::string> const& files);
+
+  cmMakefile* Makefile;
   std::vector<std::string> Files;
   bool Programs;
   std::string FilePermissions;

Source/cmInstallProgramsCommand.cxx

@@ -94,7 +94,7 @@ void cmInstallProgramsCommand::FinalPass()
                                        "CMAKE_INSTALL_DEFAULT_COMPONENT_NAME");
   std::vector<std::string> no_configurations;
   this->Makefile->AddInstallGenerator(
-    new cmInstallFilesGenerator(this->Files,
+    new cmInstallFilesGenerator(this->Makefile, this->Files,
                                 destination.c_str(), true,
                                 no_permissions, no_configurations,
                                 no_component.c_str(), no_rename));
@@ -109,7 +109,8 @@ void cmInstallProgramsCommand::FinalPass()
 std::string cmInstallProgramsCommand
 ::FindInstallSource(const char* name) const
 {
-  if(cmSystemTools::FileIsFullPath(name))
+  if(cmSystemTools::FileIsFullPath(name) ||
+     cmGeneratorExpression::Find(name) == 0)
     {
     // This is a full path.
     return name;

Tests/ExportImport/Export/CMakeLists.txt

@@ -23,6 +23,22 @@ add_library(testLib1 STATIC testLib1.c)
 add_library(testLib2 STATIC testLib2.c)
 target_link_libraries(testLib2 testLib1)
 
+# Test install(FILES) with generator expressions referencing testLib1.
+add_custom_command(TARGET testLib1 POST_BUILD
+  COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:testLib1>
+                                   $<TARGET_FILE:testLib1>.genex
+  )
+install(FILES $<TARGET_FILE:testLib1>.genex
+  DESTINATION lib
+  )
+set_property(TARGET testLib1 PROPERTY MY_FILES
+  ${CMAKE_CURRENT_SOURCE_DIR}/testLib1file1.txt
+  ${CMAKE_CURRENT_SOURCE_DIR}/testLib1file2.txt
+  )
+install(FILES $<TARGET_PROPERTY:testLib1,MY_FILES>
+  DESTINATION doc
+  )
+
 # Test library with empty link interface.  Link it to an implementation
 # dependency that itself links to dependencies publicly.
 add_library(testLib3ImpDep SHARED testLib3ImpDep.c)

Tests/ExportImport/Export/testLib1file1.txt

@@ -0,0 +1 @@
+testLib1file1

Tests/ExportImport/Export/testLib1file2.txt

@@ -0,0 +1 @@
+testLib1file2

Tests/ExportImport/Import/A/CMakeLists.txt

@@ -68,6 +68,12 @@ target_link_libraries(imp_testExe1b
   bld_testLibCycleA
   )
 
+add_custom_target(check_testLib1_genex ALL
+  COMMAND ${CMAKE_COMMAND} -DtestLib1=$<TARGET_FILE:exp_testLib1>
+                           -Dprefix=${CMAKE_INSTALL_PREFIX}
+          -P ${CMAKE_CURRENT_SOURCE_DIR}/check_testLib1_genex.cmake
+  )
+
 add_executable(cmp0022OLD_test cmp0022OLD_test_vs6_1.cpp)
 target_link_libraries(cmp0022OLD_test bld_cmp0022OLD)
 add_executable(cmp0022NEW_test cmp0022NEW_test_vs6_1.cpp)

Tests/ExportImport/Import/A/check_testLib1_genex.cmake

@@ -0,0 +1,11 @@
+foreach(f
+    "${testLib1}.genex"
+    "${prefix}/doc/testLib1file1.txt"
+    "${prefix}/doc/testLib1file2.txt"
+    )
+  if(EXISTS "${f}")
+    message(STATUS "'${f}' exists!")
+  else()
+    message(FATAL_ERROR "Missing file:\n ${f}")
+  endif()
+endforeach()