Source/cmInstallGenerator.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmInstallGenerator.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2008-01-28 13:38:35 $
   7   Version:   $Revision: 1.15 $
   8
   9   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  10   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notices for more information.
  15
  16 =========================================================================*/
  17 #include "cmInstallGenerator.h"
  18
  19 #include "cmSystemTools.h"
  20 #include "cmTarget.h"
  21
  22 //----------------------------------------------------------------------------
  23 cmInstallGenerator
  24 ::cmInstallGenerator(const char* destination,
  25                      std::vector<std::string> const& configurations,
  26                      const char* component):
  27   Destination(destination? destination:""),
  28   Configurations(configurations),
  29   Component(component? component:""),
  30   ConfigurationName(0),
  31   ConfigurationTypes(0)
  32 {
  33 }
  34
  35 //----------------------------------------------------------------------------
  36 cmInstallGenerator
  37 ::~cmInstallGenerator()
  38 {
  39 }
  40
  41 //----------------------------------------------------------------------------
  42 void
  43 cmInstallGenerator
  44 ::Generate(std::ostream& os, const char* config,
  45            std::vector<std::string> const& configurationTypes)
  46 {
  47   this->ConfigurationName = config;
  48   this->ConfigurationTypes = &configurationTypes;
  49   this->GenerateScript(os);
  50   this->ConfigurationName = 0;
  51   this->ConfigurationTypes = 0;
  52 }
  53
  54 //----------------------------------------------------------------------------
  55 void cmInstallGenerator
  56 ::AddInstallRule(
  57                  std::ostream& os,
  58                  int type,
  59                  std::vector<std::string> const& files,
  60                  bool optional /* = false */,
  61                  const char* properties /* = 0 */,
  62                  const char* permissions_file /* = 0 */,
  63                  const char* permissions_dir /* = 0 */,
  64                  const char* rename /* = 0 */,
  65                  const char* literal_args /* = 0 */,
  66                  cmInstallGeneratorIndent const& indent
  67                  )
  68 {
  69   // Use the FILE command to install the file.
  70   std::string stype;
  71   switch(type)
  72     {
  73     case cmTarget::INSTALL_DIRECTORY:stype = "DIRECTORY"; break;
  74     case cmTarget::INSTALL_PROGRAMS: stype = "PROGRAM"; break;
  75     case cmTarget::EXECUTABLE:       stype = "EXECUTABLE"; break;
  76     case cmTarget::STATIC_LIBRARY:   stype = "STATIC_LIBRARY"; break;
  77     case cmTarget::SHARED_LIBRARY:   stype = "SHARED_LIBRARY"; break;
  78     case cmTarget::MODULE_LIBRARY:   stype = "MODULE"; break;
  79     case cmTarget::INSTALL_FILES:
  80     default:                         stype = "FILE"; break;
  81     }
  82   os << indent;
  83   std::string dest = this->GetInstallDestination();
  84   os << "FILE(INSTALL DESTINATION \"" << dest << "\" TYPE " << stype.c_str();
  85   if(optional)
  86     {
  87     os << " OPTIONAL";
  88     }
  89   if(properties && *properties)
  90     {
  91     os << " PROPERTIES" << properties;
  92     }
  93   if(permissions_file && *permissions_file)
  94     {
  95     os << " PERMISSIONS" << permissions_file;
  96     }
  97   if(permissions_dir && *permissions_dir)
  98     {
  99     os << " DIR_PERMISSIONS" << permissions_dir;
 100     }
 101   if(rename && *rename)
 102     {
 103     os << " RENAME \"" << rename << "\"";
 104     }
 105   os << " FILES";
 106   if(files.size() == 1)
 107     {
 108     os << " \"" << files[0] << "\"";
 109     }
 110   else
 111     {
 112     for(std::vector<std::string>::const_iterator fi = files.begin();
 113         fi != files.end(); ++fi)
 114       {
 115       os << "\n" << indent << "  \"" << *fi << "\"";
 116       }
 117     os << "\n" << indent << " ";
 118     if(!(literal_args && *literal_args))
 119       {
 120       os << " ";
 121       }
 122     }
 123   if(literal_args && *literal_args)
 124     {
 125     os << literal_args;
 126     }
 127   os << ")\n";
 128 }
 129
 130 //----------------------------------------------------------------------------
 131 static void cmInstallGeneratorEncodeConfig(const char* config,
 132                                            std::string& result)
 133 {
 134   for(const char* c = config; *c; ++c)
 135     {
 136     if(*c >= 'a' && *c <= 'z')
 137       {
 138       result += "[";
 139       result += *c + ('A' - 'a');
 140       result += *c;
 141       result += "]";
 142       }
 143     else if(*c >= 'A' && *c <= 'Z')
 144       {
 145       result += "[";
 146       result += *c;
 147       result += *c + ('a' - 'A');
 148       result += "]";
 149       }
 150     else
 151       {
 152       result += *c;
 153       }
 154     }
 155 }
 156
 157 //----------------------------------------------------------------------------
 158 std::string
 159 cmInstallGenerator::CreateConfigTest(const char* config)
 160 {
 161   std::string result = "\"${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"^(";
 162   if(config && *config)
 163     {
 164     cmInstallGeneratorEncodeConfig(config, result);
 165     }
 166   result += ")$\"";
 167   return result;
 168 }
 169
 170 //----------------------------------------------------------------------------
 171 std::string
 172 cmInstallGenerator::CreateConfigTest(std::vector<std::string> const& configs)
 173 {
 174   std::string result = "\"${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"^(";
 175   const char* sep = "";
 176   for(std::vector<std::string>::const_iterator ci = configs.begin();
 177       ci != configs.end(); ++ci)
 178     {
 179     result += sep;
 180     sep = "|";
 181     cmInstallGeneratorEncodeConfig(ci->c_str(), result);
 182     }
 183   result += ")$\"";
 184   return result;
 185 }
 186
 187 //----------------------------------------------------------------------------
 188 std::string
 189 cmInstallGenerator::CreateComponentTest(const char* component)
 190 {
 191   std::string result = "NOT CMAKE_INSTALL_COMPONENT OR "
 192     "\"${CMAKE_INSTALL_COMPONENT}\" MATCHES \"^(";
 193   result += component;
 194   result += ")$\"";
 195   return result;
 196 }
 197
 198 //----------------------------------------------------------------------------
 199 void cmInstallGenerator::GenerateScript(std::ostream& os)
 200 {
 201   // Track indentation.
 202   Indent indent;
 203
 204   // Begin this block of installation.
 205   std::string component_test =
 206     this->CreateComponentTest(this->Component.c_str());
 207   os << indent << "IF(" << component_test << ")\n";
 208
 209   // Generate the script possibly with per-configuration code.
 210   this->GenerateScriptConfigs(os, indent.Next());
 211
 212   // End this block of installation.
 213   os << indent << "ENDIF(" << component_test << ")\n\n";
 214 }
 215
 216 //----------------------------------------------------------------------------
 217 void
 218 cmInstallGenerator::GenerateScriptConfigs(std::ostream& os,
 219                                           Indent const& indent)
 220 {
 221   if(this->Configurations.empty())
 222     {
 223     // This rule is for all configurations.
 224     this->GenerateScriptActions(os, indent);
 225     }
 226   else
 227     {
 228     // Generate a per-configuration block.
 229     std::string config_test = this->CreateConfigTest(this->Configurations);
 230     os << indent << "IF(" << config_test << ")\n";
 231     this->GenerateScriptActions(os, indent.Next());
 232     os << indent << "ENDIF(" << config_test << ")\n";
 233     }
 234 }
 235
 236 //----------------------------------------------------------------------------
 237 void cmInstallGenerator::GenerateScriptActions(std::ostream&, Indent const&)
 238 {
 239   // No actions for this generator.
 240 }
 241
 242 //----------------------------------------------------------------------------
 243 bool cmInstallGenerator::InstallsForConfig(const char* config)
 244 {
 245   // If this is not a configuration-specific rule then we install.
 246   if(this->Configurations.empty())
 247     {
 248     return true;
 249     }
 250
 251   // This is a configuration-specific rule.  Check if the config
 252   // matches this rule.
 253   std::string config_upper = cmSystemTools::UpperCase(config?config:"");
 254   for(std::vector<std::string>::const_iterator i =
 255         this->Configurations.begin();
 256       i != this->Configurations.end(); ++i)
 257     {
 258     if(cmSystemTools::UpperCase(*i) == config_upper)
 259       {
 260       return true;
 261       }
 262     }
 263   return false;
 264 }
 265
 266 //----------------------------------------------------------------------------
 267 std::string cmInstallGenerator::GetInstallDestination() const
 268 {
 269   std::string result;
 270   if(!this->Destination.empty() &&
 271      !cmSystemTools::FileIsFullPath(this->Destination.c_str()))
 272     {
 273     result = "${CMAKE_INSTALL_PREFIX}/";
 274     }
 275   result += this->Destination;
 276   return result;
 277 }