Source/cmGlobalVisualStudio6Generator.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmGlobalVisualStudio6Generator.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2009-07-14 18:16:46 $
   7   Version:   $Revision: 1.78 $
   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 "cmGlobalVisualStudio6Generator.h"
  18 #include "cmLocalVisualStudio6Generator.h"
  19 #include "cmMakefile.h"
  20 #include "cmake.h"
  21
  22 cmGlobalVisualStudio6Generator::cmGlobalVisualStudio6Generator()
  23 {
  24   this->FindMakeProgramFile = "CMakeVS6FindMake.cmake";
  25 }
  26
  27 void cmGlobalVisualStudio6Generator
  28 ::EnableLanguage(std::vector<std::string>const& lang,
  29                  cmMakefile *mf,
  30                  bool optional)
  31 {
  32   mf->AddDefinition("CMAKE_GENERATOR_CC", "cl");
  33   mf->AddDefinition("CMAKE_GENERATOR_CXX", "cl");
  34   mf->AddDefinition("CMAKE_GENERATOR_RC", "rc");
  35   mf->AddDefinition("CMAKE_GENERATOR_NO_COMPILER_ENV", "1");
  36   mf->AddDefinition("CMAKE_GENERATOR_Fortran", "ifort");
  37   mf->AddDefinition("MSVC60", "1");
  38   this->GenerateConfigurations(mf);
  39   this->cmGlobalGenerator::EnableLanguage(lang, mf, optional);
  40 }
  41
  42 void cmGlobalVisualStudio6Generator::GenerateConfigurations(cmMakefile* mf)
  43 {
  44   std::string fname= mf->GetRequiredDefinition("CMAKE_ROOT");
  45   const char* def= mf->GetDefinition( "MSPROJECT_TEMPLATE_DIRECTORY");
  46   if(def)
  47     {
  48     fname = def;
  49     }
  50   else
  51     {
  52     fname += "/Templates";
  53     }
  54   fname += "/CMakeVisualStudio6Configurations.cmake";
  55   if(!mf->ReadListFile(mf->GetCurrentListFile(), fname.c_str()))
  56     {
  57     cmSystemTools::Error("Cannot open ", fname.c_str(),
  58                          ".  Please copy this file from the main "
  59                          "CMake/Templates directory and edit it for "
  60                          "your build configurations.");
  61     }
  62   else if(!mf->GetDefinition("CMAKE_CONFIGURATION_TYPES"))
  63     {
  64     cmSystemTools::Error("CMAKE_CONFIGURATION_TYPES not set by ",
  65                          fname.c_str(),
  66                          ".  Please copy this file from the main "
  67                          "CMake/Templates directory and edit it for "
  68                          "your build configurations.");
  69     }
  70 }
  71
  72 std::string cmGlobalVisualStudio6Generator
  73 ::GenerateBuildCommand(const char* makeProgram,
  74                        const char *projectName,
  75                        const char* additionalOptions,
  76                        const char *targetName,
  77                        const char* config,
  78                        bool ignoreErrors,
  79                        bool)
  80 {
  81   // Ingoring errors is not implemented in visual studio 6
  82   (void) ignoreErrors;
  83
  84   // now build the test
  85   std::vector<std::string> mp;
  86   mp.push_back("[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio"
  87                "\\6.0\\Setup;VsCommonDir]/MSDev98/Bin");
  88   cmSystemTools::ExpandRegistryValues(mp[0]);
  89   std::string originalCommand = makeProgram;
  90   std::string makeCommand =
  91     cmSystemTools::FindProgram(makeProgram, mp);
  92   if(makeCommand.size() == 0)
  93     {
  94     std::string e = "Generator cannot find Visual Studio 6 msdev program \"";
  95     e += originalCommand;
  96     e += "\" specified by CMAKE_MAKE_PROGRAM cache entry.  ";
  97     e += "Please fix the setting.";
  98     cmSystemTools::Error(e.c_str());
  99     return "";
 100     }
 101   makeCommand = cmSystemTools::ConvertToOutputPath(makeCommand.c_str());
 102
 103   // if there are spaces in the makeCommand, assume a full path
 104   // and convert it to a path with no spaces in it as the
 105   // RunSingleCommand does not like spaces
 106 #if defined(_WIN32) && !defined(__CYGWIN__)
 107   if(makeCommand.find(' ') != std::string::npos)
 108     {
 109     cmSystemTools::GetShortPath(makeCommand.c_str(), makeCommand);
 110     }
 111 #endif
 112   makeCommand += " ";
 113   makeCommand += projectName;
 114   makeCommand += ".dsw /MAKE \"";
 115   bool clean = false;
 116   if ( targetName && strcmp(targetName, "clean") == 0 )
 117     {
 118     clean = true;
 119     targetName = "ALL_BUILD";
 120     }
 121   if (targetName && strlen(targetName))
 122     {
 123     makeCommand += targetName;
 124     }
 125   else
 126     {
 127     makeCommand += "ALL_BUILD";
 128     }
 129   makeCommand += " - ";
 130   if(config && strlen(config))
 131     {
 132     makeCommand += config;
 133     }
 134   else
 135     {
 136     makeCommand += "Debug";
 137     }
 138   if(clean)
 139     {
 140     makeCommand += "\" /CLEAN";
 141     }
 142   else
 143     {
 144     makeCommand += "\" /BUILD";
 145     }
 146   if ( additionalOptions )
 147     {
 148     makeCommand += " ";
 149     makeCommand += additionalOptions;
 150     }
 151   return makeCommand;
 152 }
 153
 154 ///! Create a local generator appropriate to this Global Generator
 155 cmLocalGenerator *cmGlobalVisualStudio6Generator::CreateLocalGenerator()
 156 {
 157   cmLocalGenerator *lg = new cmLocalVisualStudio6Generator;
 158   lg->SetGlobalGenerator(this);
 159   return lg;
 160 }
 161
 162
 163 void cmGlobalVisualStudio6Generator::Generate()
 164 {
 165   // first do the superclass method
 166   this->cmGlobalVisualStudioGenerator::Generate();
 167
 168   // Now write out the DSW
 169   this->OutputDSWFile();
 170 }
 171
 172 // Write a DSW file to the stream
 173 void cmGlobalVisualStudio6Generator
 174 ::WriteDSWFile(std::ostream& fout,cmLocalGenerator* root,
 175                std::vector<cmLocalGenerator*>& generators)
 176 {
 177   // Write out the header for a DSW file
 178   this->WriteDSWHeader(fout);
 179
 180   // Get the home directory with the trailing slash
 181   std::string homedir = root->GetMakefile()->GetStartOutputDirectory();
 182   homedir += "/";
 183
 184   unsigned int i;
 185   bool doneAllBuild = false;
 186   bool doneRunTests = false;
 187   bool doneInstall = false;
 188   bool doneEditCache = false;
 189   bool doneRebuildCache = false;
 190   bool donePackage = false;
 191
 192   for(i = 0; i < generators.size(); ++i)
 193     {
 194     if(this->IsExcluded(root, generators[i]))
 195       {
 196       continue;
 197       }
 198     cmMakefile* mf = generators[i]->GetMakefile();
 199
 200     // Get the source directory from the makefile
 201     std::string dir = mf->GetStartOutputDirectory();
 202     // remove the home directory and / from the source directory
 203     // this gives a relative path
 204     cmSystemTools::ReplaceString(dir, homedir.c_str(), "");
 205
 206     // Get the list of create dsp files names from the LocalGenerator, more
 207     // than one dsp could have been created per input CMakeLists.txt file
 208     // for each target
 209     std::vector<std::string> dspnames =
 210       static_cast<cmLocalVisualStudio6Generator *>(generators[i])
 211       ->GetCreatedProjectNames();
 212     cmTargets &tgts = generators[i]->GetMakefile()->GetTargets();
 213     std::vector<std::string>::iterator si = dspnames.begin();
 214     for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l)
 215       {
 216       // special handling for the current makefile
 217       if(mf == generators[0]->GetMakefile())
 218         {
 219         dir = "."; // no subdirectory for project generated
 220         // if this is the special ALL_BUILD utility, then
 221         // make it depend on every other non UTILITY project.
 222         // This is done by adding the names to the GetUtilities
 223         // vector on the makefile
 224         if(l->first == "ALL_BUILD" && !doneAllBuild)
 225           {
 226           unsigned int j;
 227           for(j = 0; j < generators.size(); ++j)
 228             {
 229             cmTargets &atgts = generators[j]->GetMakefile()->GetTargets();
 230             for(cmTargets::iterator al = atgts.begin();
 231                 al != atgts.end(); ++al)
 232               {
 233               if (!al->second.GetPropertyAsBool("EXCLUDE_FROM_ALL"))
 234                 {
 235                 if (al->second.GetType() == cmTarget::UTILITY ||
 236                     al->second.GetType() == cmTarget::GLOBAL_TARGET)
 237                   {
 238                   l->second.AddUtility(al->first.c_str());
 239                   }
 240                 else
 241                   {
 242                   l->second.AddLinkLibrary(al->first, cmTarget::GENERAL);
 243                   }
 244                 }
 245               }
 246             }
 247           }
 248         }
 249       // Write the project into the DSW file
 250       cmTarget* target = &l->second;
 251       const char* expath = target->GetProperty("EXTERNAL_MSPROJECT");
 252       if(expath)
 253         {
 254         std::string project = target->GetName();
 255         std::string location = expath;
 256         this->WriteExternalProject(fout, project.c_str(),
 257                                    location.c_str(), target->GetUtilities());
 258         }
 259       else
 260         {
 261           bool skip = false;
 262           // skip ALL_BUILD and RUN_TESTS if they have already been added
 263           if(l->first == "ALL_BUILD" )
 264             {
 265             if(doneAllBuild)
 266               {
 267               skip = true;
 268               }
 269             else
 270               {
 271               doneAllBuild = true;
 272               }
 273             }
 274           if(l->first == "INSTALL")
 275             {
 276             if(doneInstall)
 277               {
 278               skip = true;
 279               }
 280             else
 281               {
 282               doneInstall = true;
 283               }
 284             }
 285           if(l->first == "RUN_TESTS")
 286             {
 287             if(doneRunTests)
 288               {
 289               skip = true;
 290               }
 291             else
 292               {
 293               doneRunTests = true;
 294               }
 295             }
 296           if(l->first == "EDIT_CACHE")
 297             {
 298             if(doneEditCache)
 299               {
 300               skip = true;
 301               }
 302             else
 303               {
 304               doneEditCache = true;
 305               }
 306             }
 307           if(l->first == "REBUILD_CACHE")
 308             {
 309             if(doneRebuildCache)
 310               {
 311               skip = true;
 312               }
 313             else
 314               {
 315               doneRebuildCache = true;
 316               }
 317             }
 318           if(l->first == "PACKAGE")
 319             {
 320             if(donePackage)
 321               {
 322               skip = true;
 323               }
 324             else
 325               {
 326               donePackage = true;
 327               }
 328             }
 329           if(!skip)
 330             {
 331             this->WriteProject(fout, si->c_str(), dir.c_str(),l->second);
 332             }
 333           ++si;
 334         }
 335       }
 336     }
 337
 338   // Write the footer for the DSW file
 339   this->WriteDSWFooter(fout);
 340 }
 341
 342 void cmGlobalVisualStudio6Generator
 343 ::OutputDSWFile(cmLocalGenerator* root,
 344                 std::vector<cmLocalGenerator*>& generators)
 345 {
 346   if(generators.size() == 0)
 347     {
 348     return;
 349     }
 350   std::string fname = root->GetMakefile()->GetStartOutputDirectory();
 351   fname += "/";
 352   fname += root->GetMakefile()->GetProjectName();
 353   fname += ".dsw";
 354   std::ofstream fout(fname.c_str());
 355   if(!fout)
 356     {
 357     cmSystemTools::Error("Error can not open DSW file for write: ",
 358                          fname.c_str());
 359     cmSystemTools::ReportLastSystemError("");
 360     return;
 361     }
 362   this->WriteDSWFile(fout, root, generators);
 363 }
 364
 365 // output the DSW file
 366 void cmGlobalVisualStudio6Generator::OutputDSWFile()
 367 {
 368   std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
 369   for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
 370     {
 371     this->OutputDSWFile(it->second[0], it->second);
 372     }
 373 }
 374
 375
 376 // Utility function to make a valid VS6 *.dsp filename out
 377 // of a CMake target name:
 378 //
 379 std::string GetVS6TargetName(const std::string& targetName)
 380 {
 381   std::string name(targetName);
 382
 383   // Eliminate hyphens. VS6 cannot handle hyphens in *.dsp filenames...
 384   // Replace them with underscores.
 385   //
 386   cmSystemTools::ReplaceString(name, "-", "_");
 387
 388   return name;
 389 }
 390
 391
 392 // Write a dsp file into the DSW file,
 393 // Note, that dependencies from executables to
 394 // the libraries it uses are also done here
 395 void cmGlobalVisualStudio6Generator::WriteProject(std::ostream& fout,
 396                                                   const char* dspname,
 397                                                   const char* dir,
 398                                                   cmTarget& target)
 399 {
 400   fout << "#########################################################"
 401     "######################\n\n";
 402   fout << "Project: \"" << dspname << "\"="
 403        << dir << "\\" << dspname << ".dsp - Package Owner=<4>\n\n";
 404   fout << "Package=<5>\n{{{\n}}}\n\n";
 405   fout << "Package=<4>\n";
 406   fout << "{{{\n";
 407
 408   // insert Begin Project Dependency  Project_Dep_Name project stuff here
 409   if (target.GetType() != cmTarget::STATIC_LIBRARY)
 410     {
 411     cmTarget::LinkLibraryVectorType::const_iterator j, jend;
 412     j = target.GetLinkLibraries().begin();
 413     jend = target.GetLinkLibraries().end();
 414     for(;j!= jend; ++j)
 415       {
 416       if(j->first != dspname)
 417         {
 418         // is the library part of this DSW ? If so add dependency
 419         if(this->FindTarget(0, j->first.c_str()))
 420           {
 421           fout << "Begin Project Dependency\n";
 422           fout << "Project_Dep_Name "
 423                << GetVS6TargetName(j->first.c_str()) << "\n";
 424           fout << "End Project Dependency\n";
 425           }
 426         }
 427       }
 428     }
 429
 430   std::set<cmStdString>::const_iterator i, end;
 431   // write utility dependencies.
 432   i = target.GetUtilities().begin();
 433   end = target.GetUtilities().end();
 434   for(;i!= end; ++i)
 435     {
 436     if(*i != dspname)
 437       {
 438       std::string depName = this->GetUtilityForTarget(target, i->c_str());
 439       fout << "Begin Project Dependency\n";
 440       fout << "Project_Dep_Name " << GetVS6TargetName(depName) << "\n";
 441       fout << "End Project Dependency\n";
 442       }
 443     }
 444   fout << "}}}\n\n";
 445 }
 446
 447
 448 // Write a dsp file into the DSW file,
 449 // Note, that dependencies from executables to
 450 // the libraries it uses are also done here
 451 void cmGlobalVisualStudio6Generator::WriteExternalProject(std::ostream& fout,
 452                                const char* name,
 453                                const char* location,
 454                                const std::set<cmStdString>& dependencies)
 455 {
 456  fout << "#########################################################"
 457     "######################\n\n";
 458   fout << "Project: \"" << name << "\"="
 459        << location << " - Package Owner=<4>\n\n";
 460   fout << "Package=<5>\n{{{\n}}}\n\n";
 461   fout << "Package=<4>\n";
 462   fout << "{{{\n";
 463
 464
 465   std::set<cmStdString>::const_iterator i, end;
 466   // write dependencies.
 467   i = dependencies.begin();
 468   end = dependencies.end();
 469   for(;i!= end; ++i)
 470   {
 471     fout << "Begin Project Dependency\n";
 472     fout << "Project_Dep_Name " << GetVS6TargetName(*i) << "\n";
 473     fout << "End Project Dependency\n";
 474   }
 475   fout << "}}}\n\n";
 476 }
 477
 478
 479
 480 // Standard end of dsw file
 481 void cmGlobalVisualStudio6Generator::WriteDSWFooter(std::ostream& fout)
 482 {
 483   fout << "######################################################"
 484     "#########################\n\n";
 485   fout << "Global:\n\n";
 486   fout << "Package=<5>\n{{{\n}}}\n\n";
 487   fout << "Package=<3>\n{{{\n}}}\n\n";
 488   fout << "#####################################################"
 489     "##########################\n\n";
 490 }
 491
 492
 493 // ouput standard header for dsw file
 494 void cmGlobalVisualStudio6Generator::WriteDSWHeader(std::ostream& fout)
 495 {
 496   fout << "Microsoft Developer Studio Workspace File, Format Version 6.00\n";
 497   fout << "# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!\n\n";
 498 }
 499
 500 //----------------------------------------------------------------------------
 501 void cmGlobalVisualStudio6Generator
 502 ::GetDocumentation(cmDocumentationEntry& entry) const
 503 {
 504   entry.Name = this->GetName();
 505   entry.Brief = "Generates Visual Studio 6 project files.";
 506   entry.Full = "";
 507 }
 508
 509 //----------------------------------------------------------------------------
 510 void
 511 cmGlobalVisualStudio6Generator
 512 ::AppendDirectoryForConfig(const char* prefix,
 513                            const char* config,
 514                            const char* suffix,
 515                            std::string& dir)
 516 {
 517   if(config)
 518     {
 519     dir += prefix;
 520     dir += config;
 521     dir += suffix;
 522     }
 523 }