ENH: Further cleanup of installation script generation. The per-component and per-configuration testing is now done in cmake code instead of in the FILE(INSTALL) command. The generation of the cmake code to do these tests is centralized in cmInstallGenerator. Old-style shared library versioning and component/config support code has been removed from FILE(INSTALL). This commit is surrounded by the tags CMake-InstallGeneratorCleanup2-pre and CMake-InstallGeneratorCleanup2-post.

Source/cmFileCommand.cxx

@@ -1241,20 +1241,17 @@ bool cmFileCommand::HandleInstallCommand(std::vector<std::string> const& args)
   std::string rename = "";
   std::string destination = "";
 
-  std::set<cmStdString> components;
-  std::set<cmStdString> configurations;
   std::vector<std::string> files;
   int itype = cmTarget::INSTALL_FILES;
 
   std::map<cmStdString, const char*> properties;
   bool optional = false;
-  bool result = this->ParseInstallArgs(args, installer, components,
+  bool result = this->ParseInstallArgs(args, installer, properties,
-                                       configurations, properties,
                                        itype, rename, destination, files,
                                        optional);
   if (result == true)
     {
-    result = this->DoInstall(installer, components, configurations, properties,
+    result = this->DoInstall(installer, properties,
                              itype, rename, destination, files, optional);
     }
   return result;
@@ -1263,8 +1260,6 @@ bool cmFileCommand::HandleInstallCommand(std::vector<std::string> const& args)
 //----------------------------------------------------------------------------
 bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
                                 cmFileInstaller& installer,
-                                std::set<cmStdString>& components,
-                                std::set<cmStdString>& configurations,
                                 std::map<cmStdString, const char*>& properties,
                                 int& itype,
                                 std::string& rename,
@@ -1278,8 +1273,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
     bool doing_permissions_file = false;
     bool doing_permissions_dir = false;
     bool doing_permissions_match = false;
-    bool doing_components = false;
-    bool doing_configurations = false;
     bool use_given_permissions_file = false;
     bool use_given_permissions_dir = false;
     bool use_source_permissions = false;
@@ -1308,8 +1301,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
         doing_properties = false;
         doing_permissions_file = false;
         doing_permissions_dir = false;
-        doing_components = false;
-        doing_configurations = false;
         }
       else if ( *cstr == "TYPE" && i < args.size()-1 )
         {
@@ -1332,8 +1323,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
         doing_files = false;
         doing_permissions_file = false;
         doing_permissions_dir = false;
-        doing_components = false;
-        doing_configurations = false;
         }
       else if ( *cstr == "RENAME" && i < args.size()-1 )
         {
@@ -1351,8 +1340,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
         doing_files = false;
         doing_permissions_file = false;
         doing_permissions_dir = false;
-        doing_components = false;
-        doing_configurations = false;
         }
       else if ( *cstr == "REGEX" && i < args.size()-1 )
         {
@@ -1370,8 +1357,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
         doing_files = false;
         doing_permissions_file = false;
         doing_permissions_dir = false;
-        doing_components = false;
-        doing_configurations = false;
         }
       else if ( *cstr == "EXCLUDE"  )
         {
@@ -1401,8 +1386,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
         doing_files = false;
         doing_permissions_file = false;
         doing_permissions_dir = false;
-        doing_components = false;
-        doing_configurations = false;
         }
       else if ( *cstr == "PERMISSIONS" )
         {
@@ -1420,8 +1403,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
         doing_properties = false;
         doing_files = false;
         doing_permissions_dir = false;
-        doing_components = false;
-        doing_configurations = false;
         }
       else if ( *cstr == "DIR_PERMISSIONS" )
         {
@@ -1438,8 +1419,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
         doing_files = false;
         doing_permissions_file = false;
         doing_permissions_dir = true;
-        doing_components = false;
-        doing_configurations = false;
         }
       else if ( *cstr == "USE_SOURCE_PERMISSIONS" )
         {
@@ -1455,43 +1434,25 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
         doing_files = false;
         doing_permissions_file = false;
         doing_permissions_dir = false;
-        doing_components = false;
-        doing_configurations = false;
         use_source_permissions = true;
         }
       else if ( *cstr == "COMPONENTS"  )
         {
-        if(current_match_rule)
+        cmOStringStream e;
-          {
+        e << "INSTALL called with old-style COMPONENTS argument.  "
-          cmOStringStream e;
+          << "This script was generated with an older version of CMake.  "
-          e << "INSTALL does not allow \"" << *cstr << "\" after REGEX.";
+          << "Re-run this cmake version on your build tree.";
-          this->SetError(e.str().c_str());
+        this->SetError(e.str().c_str());
-          return false;
+        return false;
-          }
-
-        doing_properties = false;
-        doing_files = false;
-        doing_permissions_file = false;
-        doing_permissions_dir = false;
-        doing_components = true;
-        doing_configurations = false;
         }
       else if ( *cstr == "CONFIGURATIONS"  )
         {
-        if(current_match_rule)
+        cmOStringStream e;
-          {
+        e << "INSTALL called with old-style CONFIGURATIONS argument.  "
-          cmOStringStream e;
+          << "This script was generated with an older version of CMake.  "
-          e << "INSTALL does not allow \"" << *cstr << "\" after REGEX.";
+          << "Re-run this cmake version on your build tree.";
-          this->SetError(e.str().c_str());
+        this->SetError(e.str().c_str());
-          return false;
+        return false;
-          }
-
-        doing_properties = false;
-        doing_files = false;
-        doing_permissions_file = false;
-        doing_permissions_dir = false;
-        doing_components = false;
-        doing_configurations = true;
         }
       else if ( *cstr == "FILES" && !doing_files)
         {
@@ -1507,8 +1468,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
         doing_properties = false;
         doing_permissions_file = false;
         doing_permissions_dir = false;
-        doing_components = false;
-        doing_configurations = false;
         }
       else if ( doing_properties && i < args.size()-1 )
         {
@@ -1519,14 +1478,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
         {
         files.push_back(*cstr);
         }
-      else if ( doing_components )
-        {
-        components.insert(*cstr);
-        }
-      else if ( doing_configurations )
-        {
-        configurations.insert(cmSystemTools::UpperCase(*cstr));
-        }
       else if(doing_permissions_file)
         {
         if(!installer.CheckPermissions(args[i], permissions_file))
@@ -1587,6 +1538,25 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
       return false;
       }
 
+    if(properties.find("VERSION") != properties.end())
+      {
+      cmOStringStream e;
+      e << "INSTALL called with old-style VERSION property.  "
+        << "This script was generated with an older version of CMake.  "
+        << "Re-run this cmake version on your build tree.";
+      this->SetError(e.str().c_str());
+      return false;
+      }
+    if(properties.find("SOVERSION") != properties.end())
+      {
+      cmOStringStream e;
+      e << "INSTALL called with old-style SOVERSION property.  "
+        << "This script was generated with an older version of CMake.  "
+        << "Re-run this cmake version on your build tree.";
+      this->SetError(e.str().c_str());
+      return false;
+      }
+
     this->GetTargetTypeFromString(stype, itype);
 
     this->HandleInstallPermissions(installer,
@@ -1602,8 +1572,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
 
 //----------------------------------------------------------------------------
 bool cmFileCommand::DoInstall( cmFileInstaller& installer,
-                              const std::set<cmStdString>& components,
-                              const std::set<cmStdString>& configurations,
                               std::map<cmStdString, const char*>& properties,
                               const int itype,
                               const std::string& rename,
@@ -1612,38 +1580,6 @@ bool cmFileCommand::DoInstall( cmFileInstaller& installer,
                               const bool optional)
 {
   typedef std::set<cmStdString>::const_iterator iter_type;
-  // Check for component-specific installation.
-  const char* cmake_install_component =
-    this->Makefile->GetDefinition("CMAKE_INSTALL_COMPONENT");
-  if(cmake_install_component && *cmake_install_component)
-    {
-    // This install rule applies only if it is associated with the
-    // current component.
-    if(iter_type(components.find(cmake_install_component)) ==
-       components.end())
-      {
-      return true;
-      }
-    }
-
-  // Check for configuration-specific installation.
-  if(!configurations.empty())
-    {
-    std::string cmake_install_configuration = cmSystemTools::UpperCase(
-        this->Makefile->GetSafeDefinition("CMAKE_INSTALL_CONFIG_NAME"));
-    if(cmake_install_configuration.empty())
-      {
-      // No configuration specified for installation but this install
-      // rule is configuration-specific.  Skip it.
-      return true;
-      }
-    else if(iter_type(configurations.find(cmake_install_configuration)) ==
-            configurations.end())
-      {
-      // This rule is specific to a configuration not being installed.
-      return true;
-      }
-    }
 
   // Check whether files should be copied always or only if they have
   // changed.
@@ -1669,97 +1605,6 @@ bool cmFileCommand::DoInstall( cmFileInstaller& installer,
       toFile += toName;
       }
 
-    // Handle type-specific installation details.
-    switch(itype)
-      {
-      case cmTarget::MODULE_LIBRARY:
-      case cmTarget::STATIC_LIBRARY:
-      case cmTarget::SHARED_LIBRARY:
-        {
-        // Handle shared library versioning
-        const char* lib_version = 0;
-        const char* lib_soversion = 0;
-        if ( properties.find("VERSION") != properties.end() )
-          {
-          lib_version = properties["VERSION"];
-          }
-        if ( properties.find("SOVERSION") != properties.end() )
-          {
-          lib_soversion = properties["SOVERSION"];
-          }
-        if ( !lib_version && lib_soversion )
-          {
-          lib_version = lib_soversion;
-          }
-        if ( !lib_soversion && lib_version )
-          {
-          lib_soversion = lib_version;
-          }
-        if ( lib_version && lib_soversion )
-          {
-          std::string libname = toFile;
-          std::string soname = toFile;
-          std::string soname_nopath = fromName;
-          this->ComputeVersionedLibName(soname, lib_soversion);
-          this->ComputeVersionedLibName(soname_nopath, lib_soversion);
-          this->ComputeVersionedLibName(fromName, lib_version);
-          this->ComputeVersionedLibName(toFile, lib_version);
-
-          cmSystemTools::RemoveFile(soname.c_str());
-          cmSystemTools::RemoveFile(libname.c_str());
-
-          if (!cmSystemTools::CreateSymlink(soname_nopath.c_str(),
-                                            libname.c_str()) )
-            {
-            std::string errstring = "error when creating symlink from: "
-              + libname + " to " + soname_nopath;
-            this->SetError(errstring.c_str());
-            return false;
-            }
-          installer.ManifestAppend(libname);
-          if ( toFile != soname )
-            {
-            if ( !cmSystemTools::CreateSymlink(fromName.c_str(),
-                                               soname.c_str()) )
-              {
-              std::string errstring = "error when creating symlink from: "
-                + soname + " to " + fromName;
-              this->SetError(errstring.c_str());
-              return false;
-              }
-            installer.ManifestAppend(soname);
-            }
-          }
-        }
-        break;
-      case cmTarget::EXECUTABLE:
-        {
-        // Handle executable versioning
-        const char* exe_version = 0;
-        if ( properties.find("VERSION") != properties.end() )
-          {
-          exe_version = properties["VERSION"];
-          }
-        if ( exe_version )
-          {
-          std::string exename = toFile;
-          this->ComputeVersionedExeName(fromName, exe_version);
-          this->ComputeVersionedExeName(toFile, exe_version);
-          cmSystemTools::RemoveFile(exename.c_str());
-          if(!cmSystemTools::CreateSymlink(fromName.c_str(),
-                                           exename.c_str()))
-            {
-            std::string errstring = "error when creating symlink from: "
-              + exename + " to " + fromName;
-            this->SetError(errstring.c_str());
-            return false;
-            }
-          installer.ManifestAppend(exename);
-          }
-        }
-        break;
-      }
-
     // Construct the full path to the source file.  The file name may
     // have been changed above.
     std::string fromFile = fromDir;
@@ -1806,41 +1651,6 @@ bool cmFileCommand::DoInstall( cmFileInstaller& installer,
   return true;
 }
 
-//----------------------------------------------------------------------------
-void cmFileCommand::ComputeVersionedLibName(std::string& name,
-                                            const char* version)
-{
-#if defined(__APPLE__)
-  std::string ext;
-  cmsys_stl::string::size_type dot_pos = name.rfind(".");
-  if(dot_pos != name.npos)
-    {
-    ext = name.substr(dot_pos, name.npos);
-    name = name.substr(0, dot_pos);
-    }
-#endif
-  name += ".";
-  name += version;
-#if defined(__APPLE__)
-  name += ext;
-#endif
-}
-
-//----------------------------------------------------------------------------
-void cmFileCommand::ComputeVersionedExeName(std::string& name,
-                                            const char* version)
-{
-  std::string ext;
-  if(name.size() > 4 && name.substr(name.size()-4) == ".exe")
-    {
-    ext = ".exe";
-    name = name.substr(0, name.size()-4);
-    }
-  name += "-";
-  name += version;
-  name += ext;
-}
-
 //----------------------------------------------------------------------------
 bool cmFileCommand::HandleRelativePathCommand(
   std::vector<std::string> const& args)

Source/cmFileCommand.h

@@ -159,15 +159,11 @@ protected:
   bool HandleRelativePathCommand(std::vector<std::string> const& args);
   bool HandleCMakePathCommand(std::vector<std::string> const& args,
                               bool nativePath);
-  void ComputeVersionedLibName(std::string& name, const char* version);
-  void ComputeVersionedExeName(std::string& name, const char* version);
 
   // FILE(INSTALL ...) related functions
   bool HandleInstallCommand(std::vector<std::string> const& args);
   bool ParseInstallArgs(std::vector<std::string> const& args,
                         cmFileInstaller& installer,
-                        std::set<cmStdString>& components,
-                        std::set<cmStdString>& configurations,
                         std::map<cmStdString, const char*>& properties,
                         int& itype,
                         std::string& destination,
@@ -176,8 +172,6 @@ protected:
                         bool& optional
                        );
   bool DoInstall(cmFileInstaller& installer,
-                 const std::set<cmStdString>& components,
-                 const std::set<cmStdString>& configurations,
                  std::map<cmStdString, const char*>& properties,
                  const int itype,
                  const std::string& rename,

Source/cmInstallCommand.cxx

@@ -1295,7 +1295,7 @@ bool cmInstallCommand::HandleExportMode(std::vector<std::string> const& args)
 
     // Create the export install generator.
     cmInstallExportGenerator* exportGenerator = new cmInstallExportGenerator(
-                          destination, permissions.c_str(), configurations, 
+                          destination, permissions.c_str(), configurations, 0,
                           filename.c_str(), prefix.c_str(), cmakeDir.c_str());
 
     if (exportGenerator->SetExportSet(exportIt->c_str(),exportSet))

Source/cmInstallDirectoryGenerator.cxx

@@ -27,9 +27,8 @@ cmInstallDirectoryGenerator
                               std::vector<std::string> const& configurations,
                               const char* component,
                               const char* literal_args):
-  cmInstallGenerator(dest), Directories(dirs),
+  cmInstallGenerator(dest, configurations, component), Directories(dirs),
   FilePermissions(file_permissions), DirPermissions(dir_permissions),
-  Configurations(configurations), Component(component),
   LiteralArguments(literal_args)
 {
 }
@@ -41,7 +40,9 @@ cmInstallDirectoryGenerator
 }
 
 //----------------------------------------------------------------------------
-void cmInstallDirectoryGenerator::GenerateScript(std::ostream& os)
+void
+cmInstallDirectoryGenerator::GenerateScriptActions(std::ostream& os,
+                                                   Indent const& indent)
 {
   // Write code to install the directories.
   bool not_optional = false;
@@ -53,6 +54,6 @@ void cmInstallDirectoryGenerator::GenerateScript(std::ostream& os)
                        not_optional, no_properties,
                        this->FilePermissions.c_str(),
                        this->DirPermissions.c_str(),
-                       this->Configurations, this->Component.c_str(),
+                       no_rename, this->LiteralArguments.c_str(),
-                       no_rename, this->LiteralArguments.c_str());
+                       indent);
 }

Source/cmInstallDirectoryGenerator.h

@@ -35,12 +35,11 @@ public:
   virtual ~cmInstallDirectoryGenerator();
 
 protected:
-  virtual void GenerateScript(std::ostream& os);
+  typedef cmInstallGeneratorIndent Indent;
+  virtual void GenerateScriptActions(std::ostream& os, Indent const& indent);
   std::vector<std::string> Directories;
   std::string FilePermissions;
   std::string DirPermissions;
-  std::vector<std::string> Configurations;
-  std::string Component;
   std::string LiteralArguments;
 };
 

Source/cmInstallExportGenerator.cxx

@@ -23,13 +23,14 @@
 
 #include "cmInstallExportGenerator.h"
 
-cmInstallExportGenerator::cmInstallExportGenerator(const char* destination,
+cmInstallExportGenerator::cmInstallExportGenerator(
-    const char* file_permissions,
+  const char* destination,
-    std::vector<std::string> const& configurations,
+  const char* file_permissions,
-    const char* filename, const char* prefix, const char* tempOutputDir)
+  std::vector<std::string> const& configurations,
-  :cmInstallGenerator(destination)
+  const char* component,
+  const char* filename, const char* prefix, const char* tempOutputDir)
+  :cmInstallGenerator(destination, configurations, component)
   ,FilePermissions(file_permissions)
-  ,Configurations(configurations)
   ,Filename(filename)
   ,Prefix(prefix)
   ,TempOutputDir(tempOutputDir)
@@ -221,13 +222,19 @@ void cmInstallExportGenerator::GenerateScript(std::ostream& os)
       exportFileStream << "                      )\n\n";
     }
 
+  // Perform the main install script generation.
+  this->cmInstallGenerator::GenerateScript(os);
+}
+
+//----------------------------------------------------------------------------
+void cmInstallExportGenerator::GenerateScriptActions(std::ostream& os,
+                                                     Indent const& indent)
+{
   // install rule for the file created above
   std::vector<std::string> exportFile;
   exportFile.push_back(this->ExportFilename);
   this->AddInstallRule(os, this->Destination.c_str(), cmTarget::INSTALL_FILES,
                        exportFile, false, 0,
-                       this->FilePermissions.c_str(), 0, this->Configurations, 
+                       this->FilePermissions.c_str(),
-                       0, this->Filename.c_str(), 0);
+                       0, this->Filename.c_str(), 0, indent);
-
 }
-

Source/cmInstallExportGenerator.h

@@ -55,6 +55,7 @@ class cmInstallExportGenerator: public cmInstallGenerator
 public:
   cmInstallExportGenerator(const char* dest, const char* file_permissions,
                            const std::vector<std::string>& configurations,
+                           const char* component,
                            const char* filename, const char* prefix, 
                            const char* tempOutputDir);
 
@@ -73,14 +74,15 @@ protected:
     cmTargetWithProperties();
   };
 
+  typedef cmInstallGeneratorIndent Indent;
   virtual void GenerateScript(std::ostream& os);
+  virtual void GenerateScriptActions(std::ostream& os, Indent const& indent);
   static bool AddInstallLocations(cmTargetWithProperties *twp, 
                                   cmInstallTargetGenerator* generator,
                                   const char* prefix);
 
   std::string Name;
   std::string FilePermissions;
-  const std::vector<std::string> Configurations;
   std::string Filename;
   std::string Prefix;
   std::string TempOutputDir;

Source/cmInstallFilesGenerator.cxx

@@ -27,9 +27,10 @@ cmInstallFilesGenerator
                           const char* component,
                           const char* rename,
                           bool optional):
-  cmInstallGenerator(dest), Files(files), Programs(programs),
+  cmInstallGenerator(dest, configurations, component),
-  FilePermissions(file_permissions), Configurations(configurations),
+  Files(files), Programs(programs),
-  Component(component), Rename(rename), Optional(optional)
+  FilePermissions(file_permissions),
+  Rename(rename), Optional(optional)
 {
 }
 
@@ -40,7 +41,8 @@ cmInstallFilesGenerator
 }
 
 //----------------------------------------------------------------------------
-void cmInstallFilesGenerator::GenerateScript(std::ostream& os)
+void cmInstallFilesGenerator::GenerateScriptActions(std::ostream& os,
+                                                    Indent const& indent)
 {
   // Write code to install the files.
   const char* no_properties = 0;
@@ -52,7 +54,5 @@ void cmInstallFilesGenerator::GenerateScript(std::ostream& os)
                        this->Files,
                        this->Optional, no_properties,
                        this->FilePermissions.c_str(), no_dir_permissions,
-                       this->Configurations,
+                       this->Rename.c_str(), 0, indent);
-                       this->Component.c_str(),
-                       this->Rename.c_str());
 }

Source/cmInstallFilesGenerator.h

@@ -35,12 +35,11 @@ public:
   virtual ~cmInstallFilesGenerator();
 
 protected:
-  virtual void GenerateScript(std::ostream& os);
+  typedef cmInstallGeneratorIndent Indent;
+  virtual void GenerateScriptActions(std::ostream& os, Indent const& indent);
   std::vector<std::string> Files;
   bool Programs;
   std::string FilePermissions;
-  std::vector<std::string> Configurations;
-  std::string Component;
   std::string Rename;
   bool Optional;
 };

Source/cmInstallGenerator.cxx

@@ -21,10 +21,15 @@
 
 //----------------------------------------------------------------------------
 cmInstallGenerator
-::cmInstallGenerator()
+::cmInstallGenerator(const char* destination,
+                     std::vector<std::string> const& configurations,
+                     const char* component):
+  Destination(destination? destination:""),
+  Configurations(configurations),
+  Component(component? component:""),
+  ConfigurationName(0),
+  ConfigurationTypes(0)
 {
-  this->ConfigurationName = 0;
-  this->ConfigurationTypes = 0;
 }
 
 //----------------------------------------------------------------------------
@@ -57,8 +62,6 @@ void cmInstallGenerator
                  const char* properties /* = 0 */,
                  const char* permissions_file /* = 0 */,
                  const char* permissions_dir /* = 0 */,
-                 std::vector<std::string> const& configurations,
-                 const char* component /* = 0 */,
                  const char* rename /* = 0 */,
                  const char* literal_args /* = 0 */,
                  cmInstallGeneratorIndent const& indent
@@ -99,19 +102,6 @@ void cmInstallGenerator
     {
     os << " RENAME \"" << rename << "\"";
     }
-  if(!configurations.empty())
-    {
-    os << " CONFIGURATIONS";
-    for(std::vector<std::string>::const_iterator c = configurations.begin();
-        c != configurations.end(); ++c)
-      {
-      os << " \"" << *c << "\"";
-      }
-    }
-  if(component && *component)
-    {
-    os << " COMPONENTS \"" << component << "\"";
-    }
   os << " FILES";
   if(files.size() == 1)
     {
@@ -136,3 +126,115 @@ void cmInstallGenerator
     }
   os << ")\n";
 }
+
+//----------------------------------------------------------------------------
+static void cmInstallGeneratorEncodeConfig(const char* config,
+                                           std::string& result)
+{
+  for(const char* c = config; *c; ++c)
+    {
+    if(*c >= 'a' && *c <= 'z')
+      {
+      result += "[";
+      result += *c + ('A' - 'a');
+      result += *c;
+      result += "]";
+      }
+    else if(*c >= 'A' && *c <= 'Z')
+      {
+      result += "[";
+      result += *c;
+      result += *c + ('a' - 'A');
+      result += "]";
+      }
+    else
+      {
+      result += *c;
+      }
+    }
+}
+
+//----------------------------------------------------------------------------
+std::string
+cmInstallGenerator::CreateConfigTest(const char* config)
+{
+  std::string result = "\"${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"^(";
+  if(config && *config)
+    {
+    cmInstallGeneratorEncodeConfig(config, result);
+    }
+  result += ")$\"";
+  return result;
+}
+
+//----------------------------------------------------------------------------
+std::string
+cmInstallGenerator::CreateConfigTest(std::vector<std::string> const& configs)
+{
+  std::string result = "\"${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"^(";
+  const char* sep = "";
+  for(std::vector<std::string>::const_iterator ci = configs.begin();
+      ci != configs.end(); ++ci)
+    {
+    result += sep;
+    sep = "|";
+    cmInstallGeneratorEncodeConfig(ci->c_str(), result);
+    }
+  result += ")$\"";
+  return result;
+}
+
+//----------------------------------------------------------------------------
+std::string
+cmInstallGenerator::CreateComponentTest(const char* component)
+{
+  std::string result = "NOT CMAKE_INSTALL_COMPONENT OR "
+    "\"${CMAKE_INSTALL_COMPONENT}\" MATCHES \"^(";
+  result += component;
+  result += ")$\"";
+  return result;
+}
+
+//----------------------------------------------------------------------------
+void cmInstallGenerator::GenerateScript(std::ostream& os)
+{
+  // Track indentation.
+  Indent indent;
+
+  // Begin this block of installation.
+  std::string component_test =
+    this->CreateComponentTest(this->Component.c_str());
+  os << indent << "IF(" << component_test << ")\n";
+
+  // Generate the script possibly with per-configuration code.
+  this->GenerateScriptConfigs(os, indent.Next());
+
+  // End this block of installation.
+  os << indent << "ENDIF(" << component_test << ")\n";
+}
+
+//----------------------------------------------------------------------------
+void
+cmInstallGenerator::GenerateScriptConfigs(std::ostream& os,
+                                          Indent const& indent)
+{
+  if(this->Configurations.empty())
+    {
+    // This rule is for all configurations.
+    this->GenerateScriptActions(os, indent);
+    }
+  else
+    {
+    // Generate a per-configuration block.
+    std::string config_test = this->CreateConfigTest(this->Configurations);
+    os << indent << "IF(" << config_test << ")\n";
+    this->GenerateScriptActions(os, indent.Next());
+    os << indent << "ENDIF(" << config_test << ")\n";
+    }
+}
+
+//----------------------------------------------------------------------------
+void cmInstallGenerator::GenerateScriptActions(std::ostream&, Indent const&)
+{
+  // No actions for this generator.
+}

Source/cmInstallGenerator.h

@@ -54,8 +54,9 @@ inline std::ostream& operator<<(std::ostream& os,
 class cmInstallGenerator
 {
 public:
-  cmInstallGenerator();
+  cmInstallGenerator(const char* destination,
-  cmInstallGenerator(const char* dest):Destination(dest?dest:"") {}
+                     std::vector<std::string> const& configurations,
+                     const char* component);
   virtual ~cmInstallGenerator();
 
   void Generate(std::ostream& os, const char* config,
@@ -68,21 +69,33 @@ public:
     const char* properties = 0,
     const char* permissions_file = 0,
     const char* permissions_dir = 0,
-    std::vector<std::string> const& configurations 
-    = std::vector<std::string>(),
-    const char* component = 0,
     const char* rename = 0,
     const char* literal_args = 0,
     cmInstallGeneratorIndent const& indent = cmInstallGeneratorIndent()
     );
 
-  const char* GetDestination() const        {return this->Destination.c_str();}
+  const char* GetDestination() const
+    { return this->Destination.c_str(); }
+  const std::vector<std::string>& GetConfigurations() const
+    { return this->Configurations; }
 protected:
-  virtual void GenerateScript(std::ostream& os)=0;
+  typedef cmInstallGeneratorIndent Indent;
+  virtual void GenerateScript(std::ostream& os);
+  virtual void GenerateScriptConfigs(std::ostream& os, Indent const& indent);
+  virtual void GenerateScriptActions(std::ostream& os, Indent const& indent);
 
+  std::string CreateConfigTest(const char* config);
+  std::string CreateConfigTest(std::vector<std::string> const& configs);
+  std::string CreateComponentTest(const char* component);
+
+  // Information shared by most generator types.
+  std::string Destination;
+  std::vector<std::string> const Configurations;
+  std::string Component;
+
+  // Information used during generation.
   const char* ConfigurationName;
   std::vector<std::string> const* ConfigurationTypes;
-  std::string Destination;
 };
 
 #endif

Source/cmInstallScriptGenerator.cxx

@@ -19,6 +19,7 @@
 //----------------------------------------------------------------------------
 cmInstallScriptGenerator
 ::cmInstallScriptGenerator(const char* script, bool code):
+  cmInstallGenerator(0, std::vector<std::string>(), 0),
   Script(script), Code(code)
 {
 }

Source/cmInstallTargetGenerator.cxx

@@ -22,8 +22,6 @@
 #include "cmake.h"
 
 // TODO:
-//   - Consolidate component/configuration checks across multiple
-//     install generators
 //   - Skip IF(EXISTS) checks if nothing is done with the installed file
 
 //----------------------------------------------------------------------------
@@ -32,9 +30,8 @@ cmInstallTargetGenerator
                            const char* file_permissions,
                            std::vector<std::string> const& configurations,
                            const char* component, bool optional):
-  cmInstallGenerator(dest), Target(&t), ImportLibrary(implib),
+  cmInstallGenerator(dest, configurations, component), Target(&t),
-  FilePermissions(file_permissions), Configurations(configurations),
+  ImportLibrary(implib), FilePermissions(file_permissions), Optional(optional)
-  Component(component), Optional(optional)
 {
   this->Target->SetHaveInstallRule(true);
 }
@@ -52,10 +49,8 @@ void cmInstallTargetGenerator::GenerateScript(std::ostream& os)
   Indent indent;
 
   // Begin this block of installation.
-  std::string component_test = "NOT CMAKE_INSTALL_COMPONENT OR "
+  std::string component_test =
-    "\"${CMAKE_INSTALL_COMPONENT}\" MATCHES \"^(";
+    this->CreateComponentTest(this->Component.c_str());
-  component_test += this->Component;
-  component_test += ")$\"";
   os << indent << "IF(" << component_test << ")\n";
 
   // Compute the build tree directory from which to copy the target.
@@ -94,34 +89,6 @@ void cmInstallTargetGenerator::GenerateScript(std::ostream& os)
   os << indent << "ENDIF(" << component_test << ")\n";
 }
 
-//----------------------------------------------------------------------------
-static std::string cmInstallTargetGeneratorEncodeConfig(const char* config)
-{
-  std::string result;
-  for(const char* c = config; *c; ++c)
-    {
-    if(*c >= 'a' && *c <= 'z')
-      {
-      result += "[";
-      result += *c + ('A' - 'a');
-      result += *c;
-      result += "]";
-      }
-    else if(*c >= 'A' && *c <= 'Z')
-      {
-      result += "[";
-      result += *c;
-      result += *c + ('a' - 'A');
-      result += "]";
-      }
-    else
-      {
-      result += *c;
-      }
-    }
-  return result;
-}
-
 //----------------------------------------------------------------------------
 void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
                                                        const char* fromDir,
@@ -155,9 +122,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
       }
 
     // Generate a per-configuration block.
-    config_test = "\"${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"^(";
+    std::string config_test = this->CreateConfigTest(config);
-    config_test += cmInstallTargetGeneratorEncodeConfig(config);
-    config_test += ")$\"";
     os << indent << "IF(" << config_test << ")\n";
     this->GenerateScriptForConfigDir(os, fromDirConfig.c_str(), config,
                                      indent.Next());
@@ -221,12 +186,12 @@ cmInstallTargetGenerator
         from1 += ".app";
         files.push_back(from1);
         type = cmTarget::INSTALL_DIRECTORY;
+        // Need to apply install_name_tool and stripping to binary
+        // inside bundle.
         toFullPath += ".app/Contents/MacOS/";
         toFullPath += this->GetInstallFilename(this->Target, config,
                                                this->ImportLibrary, false);
         literal_args += " USE_SOURCE_PERMISSIONS";
-        // TODO: Still need to apply install_name_tool and stripping
-        // to binaries inside bundle.
         }
       else
         {
@@ -284,13 +249,10 @@ cmInstallTargetGenerator
   const char* no_dir_permissions = 0;
   const char* no_rename = 0;
   const char* no_properties = 0;
-  const char* no_component = 0;
-  std::vector<std::string> no_configurations;
   bool optional = this->Optional || this->ImportLibrary;
   this->AddInstallRule(os, this->Destination.c_str(), type, files,
                        optional, no_properties,
                        this->FilePermissions.c_str(), no_dir_permissions,
-                       no_configurations, no_component,
                        no_rename, literal_args.c_str(),
                        indent);
 

Source/cmInstallTargetGenerator.h

@@ -40,8 +40,6 @@ public:
   static std::string GetInstallFilename(cmTarget*target, const char* config, 
                                         bool implib, bool useSOName);
 
-  const std::vector<std::string>& GetConfigurations() const {return this->Configurations;}
-  
 protected:
   typedef cmInstallGeneratorIndent Indent;
   virtual void GenerateScript(std::ostream& os);
@@ -66,8 +64,6 @@ protected:
   cmTarget* Target;
   bool ImportLibrary;
   std::string FilePermissions;
-  std::vector<std::string> Configurations;
-  std::string Component;
   bool Optional;
 };