include_external_msproject: Add TYPE, GUID, PLATFORM options (#13120)

These allow one to reference more external VS project file variations.

Source/cmGlobalVisualStudio71Generator.cxx

@@ -241,9 +241,12 @@ void cmGlobalVisualStudio71Generator
 ::WriteExternalProject(std::ostream& fout, 
                        const char* name,
                        const char* location,
+                       const char* typeGuid,
                        const std::set<cmStdString>& depends)
 { 
-  fout << "Project(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \"" 
+  fout << "Project(\"{"
+       << (typeGuid ? typeGuid : "8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942")
+       << "}\") = \""
        << name << "\", \""
        << this->ConvertToSolutionPath(location) << "\", \"{"
        << this->GetGUID(name)
@@ -279,18 +282,20 @@ void cmGlobalVisualStudio71Generator
 // executables to the libraries it uses are also done here
 void cmGlobalVisualStudio71Generator
 ::WriteProjectConfigurations(std::ostream& fout, const char* name,
-                             bool partOfDefaultBuild)
+                             bool partOfDefaultBuild, const char* platformMapping)
 {
   std::string guid = this->GetGUID(name);
   for(std::vector<std::string>::iterator i = this->Configurations.begin();
       i != this->Configurations.end(); ++i)
     {
     fout << "\t\t{" << guid << "}." << *i 
-         << ".ActiveCfg = " << *i << "|Win32\n";
+         << ".ActiveCfg = " << *i << "|"
+         << (platformMapping ? platformMapping : "Win32") << std::endl;
     if(partOfDefaultBuild)
       {
       fout << "\t\t{" << guid << "}." << *i
-           << ".Build.0 = " << *i << "|Win32\n";
+           << ".Build.0 = " << *i << "|"
+           << (platformMapping ? platformMapping : "Win32") << std::endl;
       }
     }
 }

Source/cmGlobalVisualStudio71Generator.h

@@ -64,10 +64,12 @@ protected:
                            const char* name, const char* path, cmTarget &t);
   virtual void WriteProjectConfigurations(std::ostream& fout,
                                           const char* name,
-                                          bool partOfDefaultBuild);
+                                          bool partOfDefaultBuild,
+                                          const char* platformMapping = NULL);
   virtual void WriteExternalProject(std::ostream& fout,
                                     const char* name,
                                     const char* path,
+                                    const char* typeGuid,
                                     const std::set<cmStdString>& depends);
   virtual void WriteSLNFooter(std::ostream& fout);
   virtual void WriteSLNHeader(std::ostream& fout);

Source/cmGlobalVisualStudio7Generator.cxx

@@ -251,7 +251,8 @@ void cmGlobalVisualStudio7Generator::WriteTargetConfigurations(
     if(expath)
       {
       this->WriteProjectConfigurations(fout, target->GetName(),
-                                       true);
+                                       true,
+                                       target->GetProperty("VS_PLATFORM_MAPPING"));
       }
     else
       {
@@ -286,8 +287,12 @@ void cmGlobalVisualStudio7Generator::WriteTargetsToSolution(
       {
       std::string project = target->GetName();
       std::string location = expath;
-      this->WriteExternalProject(fout, project.c_str(), 
+
-                                 location.c_str(), target->GetUtilities());
+      this->WriteExternalProject(fout,
+                                 project.c_str(),
+                                 location.c_str(),
+                                 target->GetProperty("VS_PROJECT_TYPE"),
+                                 target->GetUtilities());
       written = true;
       }
     else
@@ -580,18 +585,20 @@ cmGlobalVisualStudio7Generator
 // executables to the libraries it uses are also done here
 void cmGlobalVisualStudio7Generator
 ::WriteProjectConfigurations(std::ostream& fout, const char* name,
-                             bool partOfDefaultBuild)
+                             bool partOfDefaultBuild, const char* platformMapping)
 {
   std::string guid = this->GetGUID(name);
   for(std::vector<std::string>::iterator i = this->Configurations.begin();
       i != this->Configurations.end(); ++i)
     {
     fout << "\t\t{" << guid << "}." << *i
-         << ".ActiveCfg = " << *i << "|Win32\n";
+         << ".ActiveCfg = " << *i << "|"
+         << (platformMapping ? platformMapping : "Win32") << "\n";
     if(partOfDefaultBuild)
       {
       fout << "\t\t{" << guid << "}." << *i
-           << ".Build.0 = " << *i << "|Win32\n";
+           << ".Build.0 = " << *i << "|"
+           << (platformMapping ? platformMapping : "Win32") << "\n";
       }
     }
 }
@@ -604,10 +611,14 @@ void cmGlobalVisualStudio7Generator
 void cmGlobalVisualStudio7Generator::WriteExternalProject(std::ostream& fout, 
                                const char* name,
                                const char* location,
+                               const char* typeGuid,
                                const std::set<cmStdString>&)
 { 
   std::string d = cmSystemTools::ConvertToOutputPath(location);
-  fout << "Project(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \"" 
+  fout << "Project("
+       << "\"{"
+       << (typeGuid ? typeGuid : "8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942")
+       << "}\") = \""
        << name << "\", \""
        << this->ConvertToSolutionPath(location) << "\", \"{"
        << this->GetGUID(name)

Source/cmGlobalVisualStudio7Generator.h

@@ -107,7 +107,8 @@ protected:
                            const char* name, const char* path, cmTarget &t);
   virtual void WriteProjectConfigurations(std::ostream& fout,
                                           const char* name,
-                                          bool partOfDefaultBuild);
+                                          bool partOfDefaultBuild,
+                                          const char* platformMapping = NULL);
   virtual void WriteSLNFooter(std::ostream& fout);
   virtual void WriteSLNHeader(std::ostream& fout);
   virtual std::string WriteUtilityDepend(cmTarget* target);
@@ -130,6 +131,7 @@ protected:
   virtual void WriteExternalProject(std::ostream& fout,
                                     const char* name,
                                     const char* path,
+                                    const char* typeGuid,
                                     const std::set<cmStdString>&
                                     dependencies);
 

Source/cmGlobalVisualStudio8Generator.cxx

@@ -270,20 +270,20 @@ cmGlobalVisualStudio8Generator
 void
 cmGlobalVisualStudio8Generator
 ::WriteProjectConfigurations(std::ostream& fout, const char* name,
-                             bool partOfDefaultBuild)
+                             bool partOfDefaultBuild, const char* platformMapping)
 {
   std::string guid = this->GetGUID(name);
   for(std::vector<std::string>::iterator i = this->Configurations.begin();
       i != this->Configurations.end(); ++i)
     {
     fout << "\t\t{" << guid << "}." << *i
-         << "|" << this->GetPlatformName() << ".ActiveCfg = "
+         << "|" << this->GetPlatformName() << ".ActiveCfg = " << *i << "|"
-         << *i << "|" << this->GetPlatformName() << "\n";
+         << (platformMapping ? platformMapping : this->GetPlatformName()) << "\n";
     if(partOfDefaultBuild)
       {
       fout << "\t\t{" << guid << "}." << *i
-           << "|" << this->GetPlatformName() << ".Build.0 = "
+           << "|" << this->GetPlatformName() << ".Build.0 = " << *i << "|"
-           << *i << "|" << this->GetPlatformName() << "\n";
+           << (platformMapping ? platformMapping : this->GetPlatformName()) << "\n";
       }
     }
 }

Source/cmGlobalVisualStudio8Generator.h

@@ -77,7 +77,8 @@ protected:
   virtual void WriteSolutionConfigurations(std::ostream& fout);
   virtual void WriteProjectConfigurations(std::ostream& fout,
                                           const char* name,
-                                          bool partOfDefaultBuild);
+                                          bool partOfDefaultBuild,
+                                          const char* platformMapping = NULL);
   virtual bool ComputeTargetDepends();
   virtual void WriteProjectDepends(std::ostream& fout, const char* name,
                                    const char* path, cmTarget &t);

Source/cmIncludeExternalMSProjectCommand.cxx

@@ -25,18 +25,76 @@ bool cmIncludeExternalMSProjectCommand
 #ifdef _WIN32
   if(this->Makefile->GetDefinition("WIN32"))
     {
+    enum Doing { DoingNone, DoingType, DoingGuid, DoingPlatform };
+
+    Doing doing = DoingNone;
+
+    std::string customType;
+    std::string customGuid;
+    std::string platformMapping;
+
+    std::vector<std::string> depends;
+    for (unsigned int i=2; i<args.size(); ++i)
+      {
+      if (args[i] == "TYPE")
+        {
+        doing = DoingType;
+        }
+      else if (args[i] == "GUID")
+        {
+        doing = DoingGuid;
+        }
+      else if (args[i] == "PLATFORM")
+        {
+        doing = DoingPlatform;
+        }
+      else
+        {
+        switch (doing)
+          {
+          case DoingNone: depends.push_back(args[i]);    break;
+          case DoingType: customType = args[i];          break;
+          case DoingGuid: customGuid = args[i];          break;
+          case DoingPlatform: platformMapping = args[i]; break;
+          }
+        doing = DoingNone;
+        }
+      }
+
+    // Hack together a utility target storing enough information
+    // to reproduce the target inclusion.
+    std::string utility_name = args[0];
+
     std::string path = args[1];
     cmSystemTools::ConvertToUnixSlashes(path);
 
+    if (!customGuid.empty())
+      {
+      std::string guidVariable = utility_name + "_GUID_CMAKE";
+      this->Makefile->GetCMakeInstance()->AddCacheEntry(guidVariable.c_str(),
+                                                        customGuid.c_str(),
+                                                        "Stored GUID",
+                                                        cmCacheManager::INTERNAL);
+      }
+
     // Create a target instance for this utility.
     cmTarget* target=this->Makefile->AddNewTarget(cmTarget::UTILITY, 
-                                                  args[0].c_str());
+                                                  utility_name.c_str());
+
+    target->SetProperty("GENERATOR_FILE_NAME", utility_name.c_str());
     target->SetProperty("EXTERNAL_MSPROJECT", path.c_str());
-    target->SetProperty("EXCLUDE_FROM_ALL","FALSE"); 
+    target->SetProperty("EXCLUDE_FROM_ALL", "FALSE");
-    target->SetProperty("GENERATOR_FILE_NAME", args[0].c_str());
+
-    for (unsigned int i=2; i<args.size(); ++i) 
+    if (!customType.empty())
+      target->SetProperty("VS_PROJECT_TYPE",customType.c_str());
+    if (!platformMapping.empty())
+      target->SetProperty("VS_PLATFORM_MAPPING",platformMapping.c_str());
+
+    for (std::vector<std::string>::const_iterator it = depends.begin();
+         it != depends.end();
+         ++it)
       {
-      target->AddUtility(args[i].c_str());
+      target->AddUtility(it->c_str());
       }
     }
 #endif

Source/cmIncludeExternalMSProjectCommand.h

@@ -59,11 +59,21 @@ public:
     {
     return
       "  include_external_msproject(projectname location\n"
+      "                             [TYPE projectTypeGUID]\n"
+      "                             [GUID projectGUID]\n"
+      "                             [PLATFORM platformName]\n"
       "                             dep1 dep2 ...)\n"
       "Includes an external Microsoft project in the generated workspace "
       "file.  Currently does nothing on UNIX. This will create a "
       "target named [projectname].  This can be used in the add_dependencies "
-      "command to make things depend on the external project.";
+      "command to make things depend on the external project."
+      "\n"
+      "TYPE, GUID and PLATFORM are optional parameters that allow one "
+      "to specify the type of project, id (GUID) of the project and "
+      "the name of the target platform.  "
+      "This is useful for projects requiring values other than the default "
+      "(e.g. WIX projects). "
+      "These options are not supported by the Visual Studio 6 generator.";
     }
   
   cmTypeMacro(cmIncludeExternalMSProjectCommand, cmCommand);

Source/cmLocalVisualStudio10Generator.cxx

@@ -99,6 +99,14 @@ void cmLocalVisualStudio10Generator
 {
   cmVS10XMLParser parser;
   parser.ParseFile(path); 
+
+  // if we can not find a GUID then create one
+  if(parser.GUID.empty())
+    {
+    this->GlobalGenerator->CreateGUID(name);
+    return;
+    }
+
   std::string guidStoreName = name;
   guidStoreName += "_GUID_CMAKE";
   // save the GUID in the cache