CMakeLua/Source/CPack/cmCPackGenerator.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmCPackGenerator.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2008-03-07 16:06:44 $
   7   Version:   $Revision: 1.5 $
   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
  18 #include "cmCPackGenerator.h"
  19
  20 #include "cmMakefile.h"
  21 #include "cmCPackLog.h"
  22 #include "cmake.h"
  23 #include "cmGlobalGenerator.h"
  24 #include "cmLocalGenerator.h"
  25 #include "cmGeneratedFileStream.h"
  26
  27 #include <cmsys/SystemTools.hxx>
  28 #include <cmsys/Glob.hxx>
  29 #include <memory> // auto_ptr
  30
  31 //----------------------------------------------------------------------
  32 cmCPackGenerator::cmCPackGenerator()
  33 {
  34   this->GeneratorVerbose = false;
  35   this->MakefileMap = 0;
  36   this->Logger = 0;
  37 }
  38
  39 //----------------------------------------------------------------------
  40 cmCPackGenerator::~cmCPackGenerator()
  41 {
  42   this->MakefileMap = 0;
  43 }
  44
  45 //----------------------------------------------------------------------
  46 void cmCPackGeneratorProgress(const char *msg, float prog, void* ptr)
  47 {
  48   cmCPackGenerator* self = static_cast<cmCPackGenerator*>(ptr);
  49   self->DisplayVerboseOutput(msg, prog);
  50 }
  51
  52 //----------------------------------------------------------------------
  53 void cmCPackGenerator::DisplayVerboseOutput(const char* msg,
  54   float progress)
  55 {
  56   (void)progress;
  57   cmCPackLogger(cmCPackLog::LOG_VERBOSE, "" << msg << std::endl);
  58 }
  59
  60 //----------------------------------------------------------------------
  61 int cmCPackGenerator::PrepareNames()
  62 {
  63   cmCPackLogger(cmCPackLog::LOG_DEBUG,
  64     "Create temp directory." << std::endl);
  65
  66   std::string tempDirectory = this->GetOption("CPACK_PACKAGE_DIRECTORY");
  67   tempDirectory += "/_CPack_Packages/";
  68   const char* toplevelTag = this->GetOption("CPACK_TOPLEVEL_TAG");
  69   if ( toplevelTag )
  70     {
  71     tempDirectory += toplevelTag;
  72     tempDirectory += "/";
  73     }
  74   tempDirectory += this->GetOption("CPACK_GENERATOR");
  75   std::string topDirectory = tempDirectory;
  76   this->GetOption("CPACK_PACKAGE_FILE_NAME");
  77   const char* pfname = this->GetOption("CPACK_PACKAGE_FILE_NAME");
  78   if(!pfname)
  79     {
  80     cmCPackLogger(cmCPackLog::LOG_ERROR,
  81                   "CPACK_PACKAGE_FILE_NAME not specified" << std::endl);
  82     return 0;
  83     }
  84   std::string outName = pfname;
  85   tempDirectory += "/" + outName;
  86   if(!this->GetOutputExtension())
  87     {
  88     cmCPackLogger(cmCPackLog::LOG_ERROR,
  89                   "No output extension specified" << std::endl);
  90     return 0;
  91     }
  92   outName += this->GetOutputExtension();
  93   const char* pdir = this->GetOption("CPACK_PACKAGE_DIRECTORY");
  94   if(!pdir)
  95     {
  96     cmCPackLogger(cmCPackLog::LOG_ERROR,
  97                   "CPACK_PACKAGE_DIRECTORY not specified" << std::endl);
  98     return 0;
  99     }
 100
 101   std::string destFile = pdir;
 102   destFile += "/" + outName;
 103   std::string outFile = topDirectory + "/" + outName;
 104   bool setDestDir = cmSystemTools::IsOn(this->GetOption("CPACK_SET_DESTDIR"));
 105   std::string installPrefix = tempDirectory;
 106   if (!setDestDir)
 107     {
 108     installPrefix += this->GetPackagingInstallPrefix();
 109     }
 110
 111   this->SetOptionIfNotSet("CPACK_TOPLEVEL_DIRECTORY", topDirectory.c_str());
 112   this->SetOptionIfNotSet("CPACK_TEMPORARY_DIRECTORY", tempDirectory.c_str());
 113   this->SetOptionIfNotSet("CPACK_OUTPUT_FILE_NAME", outName.c_str());
 114   this->SetOptionIfNotSet("CPACK_OUTPUT_FILE_PATH", destFile.c_str());
 115   this->SetOptionIfNotSet("CPACK_TEMPORARY_PACKAGE_FILE_NAME",
 116                           outFile.c_str());
 117   this->SetOptionIfNotSet("CPACK_INSTALL_DIRECTORY", this->GetInstallPath());
 118   this->SetOptionIfNotSet("CPACK_NATIVE_INSTALL_DIRECTORY",
 119     cmsys::SystemTools::ConvertToOutputPath(this->GetInstallPath()).c_str());
 120   this->SetOptionIfNotSet("CPACK_TEMPORARY_INSTALL_DIRECTORY",
 121                           installPrefix.c_str());
 122
 123   cmCPackLogger(cmCPackLog::LOG_DEBUG,
 124     "Look for: CPACK_PACKAGE_DESCRIPTION_FILE" << std::endl);
 125   const char* descFileName
 126     = this->GetOption("CPACK_PACKAGE_DESCRIPTION_FILE");
 127   if ( descFileName )
 128     {
 129     cmCPackLogger(cmCPackLog::LOG_DEBUG,
 130                   "Look for: " << descFileName << std::endl);
 131     if ( !cmSystemTools::FileExists(descFileName) )
 132       {
 133       cmCPackLogger(cmCPackLog::LOG_ERROR,
 134                     "Cannot find description file name: ["
 135                     << descFileName << "]" << std::endl);
 136       return 0;
 137       }
 138     std::ifstream ifs(descFileName);
 139     if ( !ifs )
 140       {
 141       cmCPackLogger(cmCPackLog::LOG_ERROR,
 142         "Cannot open description file name: " << descFileName << std::endl);
 143       return 0;
 144       }
 145     cmOStringStream ostr;
 146     std::string line;
 147
 148     cmCPackLogger(cmCPackLog::LOG_VERBOSE,
 149       "Read description file: " << descFileName << std::endl);
 150     while ( ifs && cmSystemTools::GetLineFromStream(ifs, line) )
 151       {
 152       ostr << cmSystemTools::MakeXMLSafe(line.c_str()) << std::endl;
 153       }
 154     this->SetOptionIfNotSet("CPACK_PACKAGE_DESCRIPTION", ostr.str().c_str());
 155     }
 156   if ( !this->GetOption("CPACK_PACKAGE_DESCRIPTION") )
 157     {
 158     cmCPackLogger(cmCPackLog::LOG_ERROR,
 159       "Project description not specified. Please specify "
 160       "CPACK_PACKAGE_DESCRIPTION or CPACK_PACKAGE_DESCRIPTION_FILE."
 161       << std::endl);
 162     return 0;
 163     }
 164
 165   this->SetOptionIfNotSet("CPACK_REMOVE_TOPLEVEL_DIRECTORY", "1");
 166
 167   return 1;
 168 }
 169
 170 //----------------------------------------------------------------------
 171 int cmCPackGenerator::InstallProject()
 172 {
 173   cmCPackLogger(cmCPackLog::LOG_OUTPUT, "Install projects" << std::endl);
 174   this->CleanTemporaryDirectory();
 175   std::string tempInstallDirectoryWithPostfix
 176     = this->GetOption("CPACK_TEMPORARY_INSTALL_DIRECTORY");
 177   const char* tempInstallDirectory = tempInstallDirectoryWithPostfix.c_str();
 178   int res = 1;
 179   if ( !cmsys::SystemTools::MakeDirectory(tempInstallDirectory))
 180     {
 181     cmCPackLogger(cmCPackLog::LOG_ERROR,
 182       "Problem creating temporary directory: "
 183                   << (tempInstallDirectory ? tempInstallDirectory : "(NULL}")
 184                   << std::endl);
 185     return 0;
 186     }
 187
 188   bool setDestDir = cmSystemTools::IsOn(this->GetOption("CPACK_SET_DESTDIR"));
 189   if ( setDestDir )
 190     {
 191     std::string destDir = "DESTDIR=";
 192     destDir += tempInstallDirectory;
 193     cmSystemTools::PutEnv(destDir.c_str());
 194     }
 195   else
 196     {
 197     // Make sure there is no destdir
 198     cmSystemTools::PutEnv("DESTDIR=");
 199     }
 200
 201   // If the CPackConfig file sets CPACK_INSTALL_COMMANDS then run them
 202   // as listed
 203   if ( !this->InstallProjectViaInstallCommands(
 204       setDestDir, tempInstallDirectory) )
 205     {
 206     return 0;
 207     }
 208
 209   // If the CPackConfig file sets CPACK_INSTALL_SCRIPT then run them
 210   // as listed
 211   if ( !this->InstallProjectViaInstallScript(
 212       setDestDir, tempInstallDirectory) )
 213     {
 214     return 0;
 215     }
 216
 217   // If the CPackConfig file sets CPACK_INSTALLED_DIRECTORIES
 218   // then glob it and copy it to CPACK_TEMPORARY_DIRECTORY
 219   // This is used in Source packageing
 220   if ( !this->InstallProjectViaInstalledDirectories(
 221       setDestDir, tempInstallDirectory) )
 222     {
 223     return 0;
 224     }
 225
 226
 227   // If the project is a CMAKE project then run pre-install
 228   // and then read the cmake_install script to run it
 229   if ( !this->InstallProjectViaInstallCMakeProjects(
 230       setDestDir, tempInstallDirectory) )
 231     {
 232     return 0;
 233     }
 234
 235   if ( setDestDir )
 236     {
 237     cmSystemTools::PutEnv("DESTDIR=");
 238     }
 239
 240   return res;
 241 }
 242
 243 //----------------------------------------------------------------------
 244 int cmCPackGenerator::InstallProjectViaInstallCommands(
 245   bool setDestDir, const char* tempInstallDirectory)
 246 {
 247   (void)setDestDir;
 248   (void)tempInstallDirectory;
 249   const char* installCommands = this->GetOption("CPACK_INSTALL_COMMANDS");
 250   if ( installCommands && *installCommands )
 251     {
 252     std::string tempInstallDirectoryEnv = "CMAKE_INSTALL_PREFIX=";
 253     tempInstallDirectoryEnv += tempInstallDirectory;
 254     cmSystemTools::PutEnv(tempInstallDirectoryEnv.c_str());
 255     std::vector<std::string> installCommandsVector;
 256     cmSystemTools::ExpandListArgument(installCommands,installCommandsVector);
 257     std::vector<std::string>::iterator it;
 258     for ( it = installCommandsVector.begin();
 259       it != installCommandsVector.end();
 260       ++it )
 261       {
 262       cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << it->c_str()
 263         << std::endl);
 264       std::string output;
 265       int retVal = 1;
 266       bool resB = cmSystemTools::RunSingleCommand(it->c_str(), &output,
 267         &retVal, 0, this->GeneratorVerbose, 0);
 268       if ( !resB || retVal )
 269         {
 270         std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
 271         tmpFile += "/InstallOutput.log";
 272         cmGeneratedFileStream ofs(tmpFile.c_str());
 273         ofs << "# Run command: " << it->c_str() << std::endl
 274           << "# Output:" << std::endl
 275           << output.c_str() << std::endl;
 276         cmCPackLogger(cmCPackLog::LOG_ERROR,
 277           "Problem running install command: " << it->c_str() << std::endl
 278           << "Please check " << tmpFile.c_str() << " for errors"
 279           << std::endl);
 280         return 0;
 281         }
 282       }
 283     }
 284   return 1;
 285 }
 286
 287 //----------------------------------------------------------------------
 288 int cmCPackGenerator::InstallProjectViaInstalledDirectories(
 289   bool setDestDir, const char* tempInstallDirectory)
 290 {
 291   (void)setDestDir;
 292   (void)tempInstallDirectory;
 293   std::vector<cmsys::RegularExpression> ignoreFilesRegex;
 294   const char* cpackIgnoreFiles = this->GetOption("CPACK_IGNORE_FILES");
 295   if ( cpackIgnoreFiles )
 296     {
 297     std::vector<std::string> ignoreFilesRegexString;
 298     cmSystemTools::ExpandListArgument(cpackIgnoreFiles,
 299                                       ignoreFilesRegexString);
 300     std::vector<std::string>::iterator it;
 301     for ( it = ignoreFilesRegexString.begin();
 302       it != ignoreFilesRegexString.end();
 303       ++it )
 304       {
 305       cmCPackLogger(cmCPackLog::LOG_VERBOSE,
 306         "Create ignore files regex for: " << it->c_str() << std::endl);
 307       ignoreFilesRegex.push_back(it->c_str());
 308       }
 309     }
 310   const char* installDirectories
 311     = this->GetOption("CPACK_INSTALLED_DIRECTORIES");
 312   if ( installDirectories && *installDirectories )
 313     {
 314     std::vector<std::string> installDirectoriesVector;
 315     cmSystemTools::ExpandListArgument(installDirectories,
 316       installDirectoriesVector);
 317     if ( installDirectoriesVector.size() % 2 != 0 )
 318       {
 319       cmCPackLogger(cmCPackLog::LOG_ERROR,
 320         "CPACK_INSTALLED_DIRECTORIES should contain pairs of <directory> and "
 321         "<subdirectory>. The <subdirectory> can be '.' to be installed in "
 322         "the toplevel directory of installation." << std::endl);
 323       return 0;
 324       }
 325     std::vector<std::string>::iterator it;
 326     const char* tempDir = tempInstallDirectory;
 327     for ( it = installDirectoriesVector.begin();
 328       it != installDirectoriesVector.end();
 329       ++it )
 330       {
 331       cmCPackLogger(cmCPackLog::LOG_DEBUG, "Find files" << std::endl);
 332       cmsys::Glob gl;
 333       std::string toplevel = it->c_str();
 334       it ++;
 335       std::string subdir = it->c_str();
 336       std::string findExpr = toplevel;
 337       findExpr += "/*";
 338       cmCPackLogger(cmCPackLog::LOG_OUTPUT,
 339         "- Install directory: " << toplevel << std::endl);
 340       gl.RecurseOn();
 341       if ( !gl.FindFiles(findExpr) )
 342         {
 343         cmCPackLogger(cmCPackLog::LOG_ERROR,
 344           "Cannot find any files in the installed directory" << std::endl);
 345         return 0;
 346         }
 347       std::vector<std::string>& files = gl.GetFiles();
 348       std::vector<std::string>::iterator gfit;
 349       std::vector<cmsys::RegularExpression>::iterator regIt;
 350       for ( gfit = files.begin(); gfit != files.end(); ++ gfit )
 351         {
 352         bool skip = false;
 353         std::string &inFile = *gfit;
 354         for ( regIt= ignoreFilesRegex.begin();
 355           regIt!= ignoreFilesRegex.end();
 356           ++ regIt)
 357           {
 358           if ( regIt->find(inFile.c_str()) )
 359             {
 360             cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Ignore file: "
 361               << inFile.c_str() << std::endl);
 362             skip = true;
 363             }
 364           }
 365         if ( skip )
 366           {
 367           continue;
 368           }
 369         std::string filePath = tempDir;
 370         filePath += "/" + subdir + "/"
 371           + cmSystemTools::RelativePath(toplevel.c_str(), gfit->c_str());
 372         cmCPackLogger(cmCPackLog::LOG_DEBUG, "Copy file: "
 373           << inFile.c_str() << " -> " << filePath.c_str() << std::endl);
 374         if ( !cmSystemTools::CopyFileIfDifferent(inFile.c_str(),
 375             filePath.c_str()) )
 376           {
 377           cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem copying file: "
 378             << inFile.c_str() << " -> " << filePath.c_str() << std::endl);
 379           return 0;
 380           }
 381         }
 382       }
 383     }
 384   return 1;
 385 }
 386
 387 //----------------------------------------------------------------------
 388 int cmCPackGenerator::InstallProjectViaInstallScript(
 389   bool setDestDir, const char* tempInstallDirectory)
 390 {
 391   const char* cmakeScripts
 392     = this->GetOption("CPACK_INSTALL_SCRIPT");
 393   std::string currentWorkingDirectory =
 394     cmSystemTools::GetCurrentWorkingDirectory();
 395   if ( cmakeScripts && *cmakeScripts )
 396     {
 397     cmCPackLogger(cmCPackLog::LOG_OUTPUT,
 398                   "- Install scripts: " << cmakeScripts << std::endl);
 399     std::vector<std::string> cmakeScriptsVector;
 400     cmSystemTools::ExpandListArgument(cmakeScripts,
 401       cmakeScriptsVector);
 402     std::vector<std::string>::iterator it;
 403     for ( it = cmakeScriptsVector.begin();
 404       it != cmakeScriptsVector.end();
 405       ++it )
 406       {
 407       std::string installScript = it->c_str();
 408
 409       cmCPackLogger(cmCPackLog::LOG_OUTPUT,
 410         "- Install script: " << installScript << std::endl);
 411
 412       if ( setDestDir )
 413         {
 414         // For DESTDIR based packaging, use the *project* CMAKE_INSTALL_PREFIX
 415         // underneath the tempInstallDirectory. The value of the project's
 416         // CMAKE_INSTALL_PREFIX is sent in here as the value of the
 417         // CPACK_INSTALL_PREFIX variable.
 418        std::string dir;
 419         if (this->GetOption("CPACK_INSTALL_PREFIX"))
 420           {
 421           dir += this->GetOption("CPACK_INSTALL_PREFIX");
 422           }
 423         this->SetOption("CMAKE_INSTALL_PREFIX", dir.c_str());
 424         cmCPackLogger(cmCPackLog::LOG_DEBUG,
 425           "- Using DESTDIR + CPACK_INSTALL_PREFIX... (this->SetOption)"
 426           << std::endl);
 427         cmCPackLogger(cmCPackLog::LOG_DEBUG,
 428           "- Setting CMAKE_INSTALL_PREFIX to '" << dir << "'" << std::endl);
 429         }
 430       else
 431         {
 432         this->SetOption("CMAKE_INSTALL_PREFIX", tempInstallDirectory);
 433
 434         cmCPackLogger(cmCPackLog::LOG_DEBUG,
 435           "- Using non-DESTDIR install... (this->SetOption)" << std::endl);
 436         cmCPackLogger(cmCPackLog::LOG_DEBUG,
 437           "- Setting CMAKE_INSTALL_PREFIX to '" << tempInstallDirectory
 438           << "'" << std::endl);
 439         }
 440
 441       this->SetOptionIfNotSet("CMAKE_CURRENT_BINARY_DIR",
 442         tempInstallDirectory);
 443       this->SetOptionIfNotSet("CMAKE_CURRENT_SOURCE_DIR",
 444         tempInstallDirectory);
 445       int res = this->MakefileMap->ReadListFile(0, installScript.c_str());
 446       if ( cmSystemTools::GetErrorOccuredFlag() || !res )
 447         {
 448         return 0;
 449         }
 450       }
 451     }
 452   return 1;
 453 }
 454
 455 //----------------------------------------------------------------------
 456 int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
 457   bool setDestDir, const char* tempInstallDirectory)
 458 {
 459   const char* cmakeProjects
 460     = this->GetOption("CPACK_INSTALL_CMAKE_PROJECTS");
 461   const char* cmakeGenerator
 462     = this->GetOption("CPACK_CMAKE_GENERATOR");
 463   std::string currentWorkingDirectory =
 464     cmSystemTools::GetCurrentWorkingDirectory();
 465   if ( cmakeProjects && *cmakeProjects )
 466     {
 467     if ( !cmakeGenerator )
 468       {
 469       cmCPackLogger(cmCPackLog::LOG_ERROR,
 470                     "CPACK_INSTALL_CMAKE_PROJECTS is specified, but "
 471                     "CPACK_CMAKE_GENERATOR is not. CPACK_CMAKE_GENERATOR "
 472                     "is required to install the project."
 473                     << std::endl);
 474       return 0;
 475       }
 476     std::vector<std::string> cmakeProjectsVector;
 477     cmSystemTools::ExpandListArgument(cmakeProjects,
 478       cmakeProjectsVector);
 479     std::vector<std::string>::iterator it;
 480     for ( it = cmakeProjectsVector.begin();
 481       it != cmakeProjectsVector.end();
 482       ++it )
 483       {
 484       if ( it+1 == cmakeProjectsVector.end() ||
 485         it+2 == cmakeProjectsVector.end() ||
 486         it+3 == cmakeProjectsVector.end() )
 487         {
 488         cmCPackLogger(cmCPackLog::LOG_ERROR,
 489           "Not enough items on list: CPACK_INSTALL_CMAKE_PROJECTS. "
 490           "CPACK_INSTALL_CMAKE_PROJECTS should hold quadruplet of install "
 491           "directory, install project name, install component, and install "
 492           "subdirectory."
 493           << std::endl);
 494         return 0;
 495         }
 496       std::string installDirectory = it->c_str();
 497       ++it;
 498       std::string installProjectName = it->c_str();
 499       ++it;
 500       std::string installComponent = it->c_str();
 501       ++it;
 502       std::string installSubDirectory = it->c_str();
 503       std::string installFile = installDirectory + "/cmake_install.cmake";
 504
 505       const char* buildConfig = this->GetOption("CPACK_BUILD_CONFIG");
 506       cmGlobalGenerator* globalGenerator
 507         = this->MakefileMap->GetCMakeInstance()->CreateGlobalGenerator(
 508           cmakeGenerator);
 509       // set the global flag for unix style paths on cmSystemTools as
 510       // soon as the generator is set.  This allows gmake to be used
 511       // on windows.
 512       cmSystemTools::SetForceUnixPaths(globalGenerator->GetForceUnixPaths());
 513
 514       // Does this generator require pre-install?
 515       if ( globalGenerator->GetPreinstallTargetName() )
 516         {
 517         globalGenerator->FindMakeProgram(this->MakefileMap);
 518         const char* cmakeMakeProgram
 519           = this->MakefileMap->GetDefinition("CMAKE_MAKE_PROGRAM");
 520         std::string buildCommand
 521           = globalGenerator->GenerateBuildCommand(cmakeMakeProgram,
 522             installProjectName.c_str(), 0,
 523             globalGenerator->GetPreinstallTargetName(),
 524             buildConfig, false, false);
 525         cmCPackLogger(cmCPackLog::LOG_DEBUG,
 526           "- Install command: " << buildCommand << std::endl);
 527         cmCPackLogger(cmCPackLog::LOG_OUTPUT,
 528           "- Run preinstall target for: " << installProjectName << std::endl);
 529         std::string output;
 530         int retVal = 1;
 531         bool resB =
 532           cmSystemTools::RunSingleCommand(buildCommand.c_str(),
 533                                           &output,
 534                                           &retVal,
 535                                           installDirectory.c_str(),
 536                                           this->GeneratorVerbose, 0);
 537         if ( !resB || retVal )
 538           {
 539           std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
 540           tmpFile += "/PreinstallOutput.log";
 541           cmGeneratedFileStream ofs(tmpFile.c_str());
 542           ofs << "# Run command: " << buildCommand.c_str() << std::endl
 543             << "# Directory: " << installDirectory.c_str() << std::endl
 544             << "# Output:" << std::endl
 545             << output.c_str() << std::endl;
 546           cmCPackLogger(cmCPackLog::LOG_ERROR,
 547             "Problem running install command: " << buildCommand.c_str()
 548             << std::endl
 549             << "Please check " << tmpFile.c_str() << " for errors"
 550             << std::endl);
 551           return 0;
 552           }
 553         }
 554       delete globalGenerator;
 555
 556       cmCPackLogger(cmCPackLog::LOG_OUTPUT,
 557         "- Install project: " << installProjectName << std::endl);
 558       cmake cm;
 559       cm.AddCMakePaths();
 560       cm.SetProgressCallback(cmCPackGeneratorProgress, this);
 561       cmGlobalGenerator gg;
 562       gg.SetCMakeInstance(&cm);
 563       std::auto_ptr<cmLocalGenerator> lg(gg.CreateLocalGenerator());
 564       lg->SetGlobalGenerator(&gg);
 565       cmMakefile *mf = lg->GetMakefile();
 566       std::string realInstallDirectory = tempInstallDirectory;
 567       if ( !installSubDirectory.empty() && installSubDirectory != "/" )
 568         {
 569         realInstallDirectory += installSubDirectory;
 570         }
 571
 572       if ( setDestDir )
 573         {
 574         // For DESTDIR based packaging, use the *project* CMAKE_INSTALL_PREFIX
 575         // underneath the tempInstallDirectory. The value of the project's
 576         // CMAKE_INSTALL_PREFIX is sent in here as the value of the
 577         // CPACK_INSTALL_PREFIX variable.
 578         std::string dir;
 579         if (this->GetOption("CPACK_INSTALL_PREFIX"))
 580           {
 581           dir += this->GetOption("CPACK_INSTALL_PREFIX");
 582           }
 583         mf->AddDefinition("CMAKE_INSTALL_PREFIX", dir.c_str());
 584
 585         cmCPackLogger(cmCPackLog::LOG_DEBUG,
 586           "- Using DESTDIR + CPACK_INSTALL_PREFIX... (mf->AddDefinition)"
 587           << std::endl);
 588         cmCPackLogger(cmCPackLog::LOG_DEBUG,
 589           "- Setting CMAKE_INSTALL_PREFIX to '" << dir << "'" << std::endl);
 590         }
 591       else
 592         {
 593         mf->AddDefinition("CMAKE_INSTALL_PREFIX", tempInstallDirectory);
 594
 595         cmCPackLogger(cmCPackLog::LOG_DEBUG,
 596           "- Using non-DESTDIR install... (mf->AddDefinition)" << std::endl);
 597         cmCPackLogger(cmCPackLog::LOG_DEBUG,
 598           "- Setting CMAKE_INSTALL_PREFIX to '" << tempInstallDirectory
 599           << "'" << std::endl);
 600         }
 601
 602       if ( buildConfig && *buildConfig )
 603         {
 604         mf->AddDefinition("BUILD_TYPE", buildConfig);
 605         }
 606       std::string installComponentLowerCase
 607         = cmSystemTools::LowerCase(installComponent);
 608       if ( installComponentLowerCase != "all" )
 609         {
 610         mf->AddDefinition("CMAKE_INSTALL_COMPONENT",
 611                           installComponent.c_str());
 612         }
 613
 614       // strip on TRUE, ON, 1, one or several file names, but not on
 615       // FALSE, OFF, 0 and an empty string
 616       if (!cmSystemTools::IsOff(this->GetOption("CPACK_STRIP_FILES")))
 617         {
 618         mf->AddDefinition("CMAKE_INSTALL_DO_STRIP", "1");
 619         }
 620       int res = mf->ReadListFile(0, installFile.c_str());
 621       if ( cmSystemTools::GetErrorOccuredFlag() || !res )
 622         {
 623         return 0;
 624         }
 625       }
 626     }
 627   return 1;
 628 }
 629
 630 //----------------------------------------------------------------------
 631 bool cmCPackGenerator::ReadListFile(const char* moduleName)
 632 {
 633   std::string fullPath = this->MakefileMap->GetModulesFile(moduleName);
 634   return this->MakefileMap->ReadListFile(0, fullPath.c_str());
 635 }
 636
 637 //----------------------------------------------------------------------
 638 void cmCPackGenerator::SetOptionIfNotSet(const char* op,
 639   const char* value)
 640 {
 641   const char* def = this->MakefileMap->GetDefinition(op);
 642   if ( def && *def )
 643     {
 644     return;
 645     }
 646   this->SetOption(op, value);
 647 }
 648
 649 //----------------------------------------------------------------------
 650 void cmCPackGenerator::SetOption(const char* op, const char* value)
 651 {
 652   if ( !op )
 653     {
 654     return;
 655     }
 656   if ( !value )
 657     {
 658     this->MakefileMap->RemoveDefinition(op);
 659     return;
 660     }
 661   cmCPackLogger(cmCPackLog::LOG_DEBUG, this->GetNameOfClass()
 662     << "::SetOption(" << op << ", " << value << ")" << std::endl);
 663   this->MakefileMap->AddDefinition(op, value);
 664 }
 665
 666 //----------------------------------------------------------------------
 667 int cmCPackGenerator::DoPackage()
 668 {
 669   cmCPackLogger(cmCPackLog::LOG_OUTPUT,
 670     "Create package using " << this->Name.c_str() << std::endl);
 671
 672   if ( !this->PrepareNames() )
 673     {
 674     return 0;
 675     }
 676
 677   if ( cmSystemTools::IsOn(
 678       this->GetOption("CPACK_REMOVE_TOPLEVEL_DIRECTORY")) )
 679     {
 680     const char* toplevelDirectory
 681       = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
 682     if ( cmSystemTools::FileExists(toplevelDirectory) )
 683       {
 684       cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Remove toplevel directory: "
 685         << toplevelDirectory << std::endl);
 686       if ( !cmSystemTools::RemoveADirectory(toplevelDirectory) )
 687         {
 688         cmCPackLogger(cmCPackLog::LOG_ERROR,
 689           "Problem removing toplevel directory: "
 690           << toplevelDirectory
 691           << std::endl);
 692         return 0;
 693         }
 694       }
 695     }
 696   cmCPackLogger(cmCPackLog::LOG_DEBUG,
 697                 "About to install project " << std::endl);
 698
 699   if ( !this->InstallProject() )
 700     {
 701     return 0;
 702     }
 703   cmCPackLogger(cmCPackLog::LOG_DEBUG,
 704                 "Done install project " << std::endl);
 705
 706
 707   const char* tempPackageFileName = this->GetOption(
 708     "CPACK_TEMPORARY_PACKAGE_FILE_NAME");
 709   const char* packageFileName = this->GetOption("CPACK_OUTPUT_FILE_PATH");
 710   const char* tempDirectory = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
 711
 712
 713   cmCPackLogger(cmCPackLog::LOG_DEBUG, "Find files" << std::endl);
 714   cmsys::Glob gl;
 715   std::string findExpr = tempDirectory;
 716   findExpr += "/*";
 717   gl.RecurseOn();
 718   if ( !gl.FindFiles(findExpr) )
 719     {
 720     cmCPackLogger(cmCPackLog::LOG_ERROR,
 721       "Cannot find any files in the packaging tree" << std::endl);
 722     return 0;
 723     }
 724
 725   cmCPackLogger(cmCPackLog::LOG_OUTPUT, "Compress package" << std::endl);
 726   cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Compress files to: "
 727     << (tempPackageFileName ? tempPackageFileName : "(NULL)") << std::endl);
 728   if ( cmSystemTools::FileExists(tempPackageFileName) )
 729     {
 730     cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Remove old package file"
 731       << std::endl);
 732     cmSystemTools::RemoveFile(tempPackageFileName);
 733     }
 734   if ( cmSystemTools::IsOn(this->GetOption(
 735         "CPACK_INCLUDE_TOPLEVEL_DIRECTORY")) )
 736     {
 737     tempDirectory = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
 738     }
 739   if ( !this->CompressFiles(tempPackageFileName,
 740       tempDirectory, gl.GetFiles()) || cmSystemTools::GetErrorOccuredFlag())
 741     {
 742     cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem compressing the directory"
 743       << std::endl);
 744     return 0;
 745     }
 746
 747   cmCPackLogger(cmCPackLog::LOG_OUTPUT, "Finalize package" << std::endl);
 748   cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Copy final package: "
 749                 << (tempPackageFileName ? tempPackageFileName : "(NULL)" )
 750                 << " to "
 751                 << (packageFileName ? packageFileName : "(NULL)")
 752                 << std::endl);
 753   if ( !cmSystemTools::CopyFileIfDifferent(tempPackageFileName,
 754       packageFileName) )
 755     {
 756     cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem copying the package: "
 757                   << (tempPackageFileName ? tempPackageFileName : "(NULL)" )
 758                   << " to "
 759                   << (packageFileName ? packageFileName : "(NULL)")
 760                   << std::endl);
 761     return 0;
 762     }
 763
 764   cmCPackLogger(cmCPackLog::LOG_OUTPUT, "Package "
 765                 << (packageFileName ? packageFileName : "(NULL)")
 766                 << " generated." << std::endl);
 767   return 1;
 768 }
 769
 770 //----------------------------------------------------------------------
 771 int cmCPackGenerator::Initialize(const char* name, cmMakefile* mf,
 772  const char* argv0)
 773 {
 774   this->MakefileMap = mf;
 775   this->Name = name;
 776   if ( !this->FindRunningCMake(argv0) )
 777     {
 778     cmCPackLogger(cmCPackLog::LOG_ERROR,
 779       "Cannot initialize the generator" << std::endl);
 780     return 0;
 781     }
 782   // set the running generator name
 783   this->SetOption("CPACK_GENERATOR", this->Name.c_str());
 784   // Load the project specific config file
 785   const char* config =
 786     this->GetOption("CPACK_PROJECT_CONFIG_FILE");
 787   if(config)
 788     {
 789     mf->ReadListFile(config);
 790     }
 791   int result = this->InitializeInternal();
 792   if (cmSystemTools::GetErrorOccuredFlag())
 793     {
 794     return 0;
 795     }
 796
 797   // If a generator subclass did not already set this option in its
 798   // InitializeInternal implementation, and the project did not already set
 799   // it, the default value should be:
 800   this->SetOptionIfNotSet("CPACK_PACKAGING_INSTALL_PREFIX", "/");
 801
 802   return result;
 803 }
 804
 805 //----------------------------------------------------------------------
 806 int cmCPackGenerator::InitializeInternal()
 807 {
 808   return 1;
 809 }
 810
 811 //----------------------------------------------------------------------
 812 bool cmCPackGenerator::IsSet(const char* name) const
 813 {
 814   return this->MakefileMap->IsSet(name);
 815 }
 816
 817 //----------------------------------------------------------------------
 818 const char* cmCPackGenerator::GetOption(const char* op)
 819 {
 820   return this->MakefileMap->GetDefinition(op);
 821 }
 822
 823 //----------------------------------------------------------------------
 824 int cmCPackGenerator::FindRunningCMake(const char* arg0)
 825 {
 826   int found = 0;
 827   // Find our own executable.
 828   std::vector<cmStdString> failures;
 829   this->CPackSelf = arg0;
 830   cmSystemTools::ConvertToUnixSlashes(this->CPackSelf);
 831   failures.push_back(this->CPackSelf);
 832   this->CPackSelf = cmSystemTools::FindProgram(this->CPackSelf.c_str());
 833   if(!cmSystemTools::FileExists(this->CPackSelf.c_str()))
 834     {
 835     failures.push_back(this->CPackSelf);
 836     this->CPackSelf =  "/usr/local/bin/ctest";
 837     }
 838   if(!cmSystemTools::FileExists(this->CPackSelf.c_str()))
 839     {
 840     failures.push_back(this->CPackSelf);
 841     cmOStringStream msg;
 842     msg << "CPack can not find the command line program ctest.\n";
 843     msg << "  argv[0] = \"" << arg0 << "\"\n";
 844     msg << "  Attempted paths:\n";
 845     std::vector<cmStdString>::iterator i;
 846     for(i=failures.begin(); i != failures.end(); ++i)
 847       {
 848       msg << "    \"" << i->c_str() << "\"\n";
 849       }
 850     cmCPackLogger(cmCPackLog::LOG_ERROR, msg.str().c_str()
 851       << std::endl);
 852     return 0;
 853     }
 854   std::string dir;
 855   std::string file;
 856   if(cmSystemTools::SplitProgramPath(this->CPackSelf.c_str(),
 857       dir, file, true))
 858     {
 859     this->CMakeSelf = dir += "/cmake";
 860     this->CMakeSelf += cmSystemTools::GetExecutableExtension();
 861     if(cmSystemTools::FileExists(this->CMakeSelf.c_str()))
 862       {
 863       found = 1;
 864       }
 865     }
 866   if ( !found )
 867     {
 868     failures.push_back(this->CMakeSelf);
 869 #ifdef CMAKE_BUILD_DIR
 870     std::string intdir = ".";
 871 #ifdef  CMAKE_INTDIR
 872     intdir = CMAKE_INTDIR;
 873 #endif
 874     this->CMakeSelf = CMAKE_BUILD_DIR;
 875     this->CMakeSelf += "/bin/";
 876     this->CMakeSelf += intdir;
 877     this->CMakeSelf += "/cmake";
 878     this->CMakeSelf += cmSystemTools::GetExecutableExtension();
 879 #endif
 880     if(!cmSystemTools::FileExists(this->CMakeSelf.c_str()))
 881       {
 882       failures.push_back(this->CMakeSelf);
 883       cmOStringStream msg;
 884       msg << "CPack can not find the command line program cmake.\n";
 885       msg << "  argv[0] = \"" << arg0 << "\"\n";
 886       msg << "  Attempted paths:\n";
 887       std::vector<cmStdString>::iterator i;
 888       for(i=failures.begin(); i != failures.end(); ++i)
 889         {
 890         msg << "    \"" << i->c_str() << "\"\n";
 891         }
 892       cmCPackLogger(cmCPackLog::LOG_ERROR, msg.str().c_str()
 893         << std::endl);
 894       return 0;
 895       }
 896     }
 897   // do CMAKE_ROOT, look for the environment variable first
 898   std::string cMakeRoot;
 899   std::string modules;
 900   cmCPackLogger(cmCPackLog::LOG_DEBUG, "Looking for CMAKE_ROOT" << std::endl);
 901   if (getenv("CMAKE_ROOT"))
 902     {
 903     cMakeRoot = getenv("CMAKE_ROOT");
 904     modules = cMakeRoot + "/Modules/CMake.cmake";
 905     }
 906   if(modules.empty() || !cmSystemTools::FileExists(modules.c_str()))
 907     {
 908     // next try exe/..
 909     cMakeRoot  = cmSystemTools::GetProgramPath(this->CMakeSelf.c_str());
 910     std::string::size_type slashPos = cMakeRoot.rfind("/");
 911     if(slashPos != std::string::npos)
 912       {
 913       cMakeRoot = cMakeRoot.substr(0, slashPos);
 914       }
 915     // is there no Modules direcory there?
 916     modules = cMakeRoot + "/Modules/CMake.cmake";
 917     cmCPackLogger(cmCPackLog::LOG_DEBUG, "Looking for CMAKE_ROOT: "
 918       << modules.c_str() << std::endl);
 919     }
 920
 921   if (!cmSystemTools::FileExists(modules.c_str()))
 922     {
 923     // try exe/../share/cmake
 924     cMakeRoot += CMAKE_DATA_DIR;
 925     modules = cMakeRoot + "/Modules/CMake.cmake";
 926     cmCPackLogger(cmCPackLog::LOG_DEBUG, "Looking for CMAKE_ROOT: "
 927       << modules.c_str() << std::endl);
 928     }
 929 #ifdef CMAKE_ROOT_DIR
 930   if (!cmSystemTools::FileExists(modules.c_str()))
 931     {
 932     // try compiled in root directory
 933     cMakeRoot = CMAKE_ROOT_DIR;
 934     modules = cMakeRoot + "/Modules/CMake.cmake";
 935     cmCPackLogger(cmCPackLog::LOG_DEBUG, "Looking for CMAKE_ROOT: "
 936       << modules.c_str() << std::endl);
 937     }
 938 #endif
 939 #ifdef CMAKE_PREFIX
 940   if (!cmSystemTools::FileExists(modules.c_str()))
 941     {
 942     // try compiled in install prefix
 943     cMakeRoot = CMAKE_PREFIX CMAKE_DATA_DIR;
 944     modules = cMakeRoot + "/Modules/CMake.cmake";
 945     cmCPackLogger(cmCPackLog::LOG_DEBUG, "Looking for CMAKE_ROOT: "
 946       << modules.c_str() << std::endl);
 947     }
 948 #endif
 949   if (!cmSystemTools::FileExists(modules.c_str()))
 950     {
 951     // try
 952     cMakeRoot  = cmSystemTools::GetProgramPath(this->CMakeSelf.c_str());
 953     cMakeRoot += CMAKE_DATA_DIR;
 954     modules = cMakeRoot +  "/Modules/CMake.cmake";
 955     cmCPackLogger(cmCPackLog::LOG_DEBUG, "Looking for CMAKE_ROOT: "
 956       << modules.c_str() << std::endl);
 957     }
 958   if(!cmSystemTools::FileExists(modules.c_str()))
 959     {
 960     // next try exe
 961     cMakeRoot  = cmSystemTools::GetProgramPath(this->CMakeSelf.c_str());
 962     // is there no Modules direcory there?
 963     modules = cMakeRoot + "/Modules/CMake.cmake";
 964     cmCPackLogger(cmCPackLog::LOG_DEBUG, "Looking for CMAKE_ROOT: "
 965       << modules.c_str() << std::endl);
 966     }
 967   if (!cmSystemTools::FileExists(modules.c_str()))
 968     {
 969     // couldn't find modules
 970     cmCPackLogger(cmCPackLog::LOG_ERROR,
 971       "Could not find CMAKE_ROOT !!!" << std::endl
 972       << "CMake has most likely not been installed correctly." << std::endl
 973       <<"Modules directory not found in" << std::endl
 974       << cMakeRoot.c_str()
 975       << std::endl);
 976     return 0;
 977     }
 978   this->CMakeRoot = cMakeRoot;
 979   cmCPackLogger(cmCPackLog::LOG_DEBUG, "Looking for CMAKE_ROOT: "
 980     << this->CMakeRoot.c_str() << std::endl);
 981   this->SetOption("CMAKE_ROOT", this->CMakeRoot.c_str());
 982   return 1;
 983 }
 984
 985 //----------------------------------------------------------------------
 986 int cmCPackGenerator::CompressFiles(const char* outFileName,
 987   const char* toplevel, const std::vector<std::string>& files)
 988 {
 989   (void)outFileName;
 990   (void)toplevel;
 991   (void)files;
 992   return 0;
 993 }
 994
 995 //----------------------------------------------------------------------
 996 const char* cmCPackGenerator::GetInstallPath()
 997 {
 998   if ( !this->InstallPath.empty() )
 999     {
1000     return this->InstallPath.c_str();
1001     }
1002 #if defined(_WIN32) && !defined(__CYGWIN__)
1003   const char* prgfiles = cmsys::SystemTools::GetEnv("ProgramFiles");
1004   const char* sysDrive = cmsys::SystemTools::GetEnv("SystemDrive");
1005   if ( prgfiles )
1006     {
1007     this->InstallPath = prgfiles;
1008     }
1009   else if ( sysDrive )
1010     {
1011     this->InstallPath = sysDrive;
1012     this->InstallPath += "/Program Files";
1013     }
1014   else
1015     {
1016     this->InstallPath = "c:/Program Files";
1017     }
1018   this->InstallPath += "/";
1019   this->InstallPath += this->GetOption("CPACK_PACKAGE_NAME");
1020   this->InstallPath += "-";
1021   this->InstallPath += this->GetOption("CPACK_PACKAGE_VERSION");
1022 #else
1023   this->InstallPath = "/usr/local/";
1024 #endif
1025   return this->InstallPath.c_str();
1026 }
1027
1028 //----------------------------------------------------------------------
1029 const char* cmCPackGenerator::GetPackagingInstallPrefix()
1030 {
1031   cmCPackLogger(cmCPackLog::LOG_DEBUG, "GetPackagingInstallPrefix: '"
1032     << this->GetOption("CPACK_PACKAGING_INSTALL_PREFIX") << "'" << std::endl);
1033
1034   return this->GetOption("CPACK_PACKAGING_INSTALL_PREFIX");
1035 }
1036
1037 //----------------------------------------------------------------------
1038 std::string cmCPackGenerator::FindTemplate(const char* name)
1039 {
1040   cmCPackLogger(cmCPackLog::LOG_DEBUG, "Look for template: "
1041     << (name ? name : "(NULL)") << std::endl);
1042   std::string ffile = this->MakefileMap->GetModulesFile(name);
1043   cmCPackLogger(cmCPackLog::LOG_DEBUG, "Found template: "
1044     << ffile.c_str() << std::endl);
1045   return ffile;
1046 }
1047
1048 //----------------------------------------------------------------------
1049 bool cmCPackGenerator::ConfigureString(const std::string& inString,
1050   std::string& outString)
1051 {
1052   this->MakefileMap->ConfigureString(inString,
1053     outString, true, false);
1054   return true;
1055 }
1056
1057 //----------------------------------------------------------------------
1058 bool cmCPackGenerator::ConfigureFile(const char* inName,
1059   const char* outName, bool copyOnly /* = false */)
1060 {
1061   return this->MakefileMap->ConfigureFile(inName, outName,
1062     copyOnly, true, false) == 1;
1063 }
1064
1065 //----------------------------------------------------------------------
1066 int cmCPackGenerator::CleanTemporaryDirectory()
1067 {
1068   std::string tempInstallDirectoryWithPostfix
1069     = this->GetOption("CPACK_TEMPORARY_INSTALL_DIRECTORY");
1070   const char* tempInstallDirectory = tempInstallDirectoryWithPostfix.c_str();
1071   if(cmsys::SystemTools::FileExists(tempInstallDirectory))
1072     {
1073     cmCPackLogger(cmCPackLog::LOG_OUTPUT,
1074                   "- Clean temporary : "
1075                   << tempInstallDirectory << std::endl);
1076     if(!cmsys::SystemTools::RemoveADirectory(tempInstallDirectory))
1077       {
1078       cmCPackLogger(cmCPackLog::LOG_ERROR,
1079                     "Problem removing temporary directory: " <<
1080                     tempInstallDirectory
1081                     << std::endl);
1082       return 0;
1083       }
1084     }
1085   return 1;
1086 }