cmStrCat: use where possible in Apple-specific sources

5 files changed, 82 insertions, 73 deletions

diff --git a/Source/CPack/cmCPackDragNDropGenerator.cxx b/Source/CPack/cmCPackDragNDropGenerator.cxx
index bd92839..82f58a2 100644
--- a/Source/CPack/cmCPackDragNDropGenerator.cxx
+++ b/Source/CPack/cmCPackDragNDropGenerator.cxx
@@ -136,8 +136,10 @@ int cmCPackDragNDropGenerator::InitializeInternal()
       return 0;
     }
     for (auto const& language : languages) {
-      std::string license = slaDirectory + "/" + language + ".license.txt";
-      std::string license_rtf = slaDirectory + "/" + language + ".license.rtf";
+      std::string license =
+        cmStrCat(slaDirectory, "/", language, ".license.txt");
+      std::string license_rtf =
+        cmStrCat(slaDirectory, "/", language, ".license.rtf");
       if (!singleLicense) {
         if (!cmSystemTools::FileExists(license) &&
             !cmSystemTools::FileExists(license_rtf)) {
@@ -148,7 +150,7 @@ int cmCPackDragNDropGenerator::InitializeInternal()
           return 0;
         }
       }
-      std::string menu = slaDirectory + "/" + language + ".menu.txt";
+      std::string menu = cmStrCat(slaDirectory, "/", language, ".menu.txt");
       if (!cmSystemTools::FileExists(menu)) {
         cmCPackLogger(cmCPackLog::LOG_ERROR,
                       "Missing menu file " << language << ".menu.txt"
@@ -192,7 +194,7 @@ int cmCPackDragNDropGenerator::PackageFiles()
   // loop to create dmg files
   packageFileNames.clear();
   for (auto const& package_file : package_files) {
-    std::string full_package_name = std::string(toplevel) + std::string("/");
+    std::string full_package_name = cmStrCat(toplevel, "/");
     if (package_file == "ALL_IN_ONE") {
       full_package_name += this->GetOption("CPACK_PACKAGE_FILE_NAME");
     } else {
@@ -711,8 +713,8 @@ std::string cmCPackDragNDropGenerator::GetComponentInstallDirNameSuffix(
   if (this->componentPackageMethod == ONE_PACKAGE_PER_GROUP) {
     // We have to find the name of the COMPONENT GROUP
     // the current COMPONENT belongs to.
-    std::string groupVar =
-      "CPACK_COMPONENT_" + cmSystemTools::UpperCase(componentName) + "_GROUP";
+    std::string groupVar = cmStrCat(
+      "CPACK_COMPONENT_", cmSystemTools::UpperCase(componentName), "_GROUP");
     cmValue _groupName = this->GetOption(groupVar);
     if (_groupName) {
       std::string groupName = _groupName;
@@ -723,8 +725,8 @@ std::string cmCPackDragNDropGenerator::GetComponentInstallDirNameSuffix(
     }
   }
 
-  std::string componentFileName =
-    "CPACK_DMG_" + cmSystemTools::UpperCase(componentName) + "_FILE_NAME";
+  std::string componentFileName = cmStrCat(
+    "CPACK_DMG_", cmSystemTools::UpperCase(componentName), "_FILE_NAME");
   if (this->IsSet(componentFileName)) {
     return this->GetOption(componentFileName);
   }
@@ -808,12 +810,12 @@ bool cmCPackDragNDropGenerator::WriteLicense(RezDoc& rez, size_t licenseNumber,
     actual_license = licenseFile;
   } else {
     std::string license_wo_ext =
-      slaDirectory + "/" + licenseLanguage + ".license";
-    if (cmSystemTools::FileExists(license_wo_ext + ".txt")) {
-      actual_license = license_wo_ext + ".txt";
+      cmStrCat(slaDirectory, "/", licenseLanguage, ".license");
+    if (cmSystemTools::FileExists(cmStrCat(license_wo_ext, ".txt"))) {
+      actual_license = cmStrCat(license_wo_ext, ".txt");
     } else {
       licenseArray = &rez.RTF;
-      actual_license = license_wo_ext + ".rtf";
+      actual_license = cmStrCat(license_wo_ext, ".rtf");
     }
   }
 
@@ -836,7 +838,7 @@ bool cmCPackDragNDropGenerator::WriteLicense(RezDoc& rez, size_t licenseNumber,
     } else {
       std::vector<std::string> lines;
       std::string actual_menu =
-        slaDirectory + "/" + licenseLanguage + ".menu.txt";
+        cmStrCat(slaDirectory, "/", licenseLanguage, ".menu.txt");
       if (!this->ReadFile(actual_menu, lines, error)) {
         return false;
       }
diff --git a/Source/CPack/cmCPackPKGGenerator.cxx b/Source/CPack/cmCPackPKGGenerator.cxx
index 554cfcd..f113ff4 100644
--- a/Source/CPack/cmCPackPKGGenerator.cxx
+++ b/Source/CPack/cmCPackPKGGenerator.cxx
@@ -38,13 +38,12 @@ std::string cmCPackPKGGenerator::GetPackageName(
   if (component.ArchiveFile.empty()) {
     std::string packagesDir =
       cmStrCat(this->GetOption("CPACK_TEMPORARY_DIRECTORY"), ".dummy");
-    std::ostringstream out;
-    out << cmSystemTools::GetFilenameWithoutLastExtension(packagesDir) << "-"
-        << component.Name << ".pkg";
-    return out.str();
+    return cmStrCat(
+      cmSystemTools::GetFilenameWithoutLastExtension(packagesDir), "-",
+      component.Name, ".pkg");
   }
 
-  return component.ArchiveFile + ".pkg";
+  return cmStrCat(component.ArchiveFile, ".pkg");
 }
 
 void cmCPackPKGGenerator::CreateBackground(const char* themeName,
@@ -160,14 +159,15 @@ void cmCPackPKGGenerator::WriteDistributionFile(const char* metapackageFile,
   for (auto const& comp : this->Components) {
     if (!comp.second.Group) {
       xChoiceOut.StartElement("line");
-      xChoiceOut.Attribute("choice", comp.first + "Choice");
+      xChoiceOut.Attribute("choice", cmStrCat(comp.first, "Choice"));
       xChoiceOut.Content(""); // Avoid self-closing tag.
       xChoiceOut.EndElement();
     }
   }
   if (!this->PostFlightComponent.Name.empty()) {
     xChoiceOut.StartElement("line");
-    xChoiceOut.Attribute("choice", PostFlightComponent.Name + "Choice");
+    xChoiceOut.Attribute("choice",
+                         cmStrCat(PostFlightComponent.Name, "Choice"));
     xChoiceOut.Content(""); // Avoid self-closing tag.
     xChoiceOut.EndElement();
   }
@@ -207,14 +207,14 @@ void cmCPackPKGGenerator::CreateChoiceOutline(
   const cmCPackComponentGroup& group, cmXMLWriter& xout)
 {
   xout.StartElement("line");
-  xout.Attribute("choice", group.Name + "Choice");
+  xout.Attribute("choice", cmStrCat(group.Name, "Choice"));
   for (cmCPackComponentGroup* subgroup : group.Subgroups) {
     CreateChoiceOutline(*subgroup, xout);
   }
 
   for (cmCPackComponent* comp : group.Components) {
     xout.StartElement("line");
-    xout.Attribute("choice", comp->Name + "Choice");
+    xout.Attribute("choice", cmStrCat(comp->Name, "Choice"));
     xout.Content(""); // Avoid self-closing tag.
     xout.EndElement();
   }
@@ -225,7 +225,7 @@ void cmCPackPKGGenerator::CreateChoice(const cmCPackComponentGroup& group,
                                        cmXMLWriter& xout)
 {
   xout.StartElement("choice");
-  xout.Attribute("id", group.Name + "Choice");
+  xout.Attribute("id", cmStrCat(group.Name, "Choice"));
   xout.Attribute("title", group.DisplayName);
   xout.Attribute("start_selected", "true");
   xout.Attribute("start_enabled", "true");
@@ -249,7 +249,7 @@ void cmCPackPKGGenerator::CreateChoice(const cmCPackComponent& component,
   }
 
   xout.StartElement("choice");
-  xout.Attribute("id", component.Name + "Choice");
+  xout.Attribute("id", cmStrCat(component.Name, "Choice"));
   xout.Attribute("title", component.DisplayName);
   xout.Attribute(
     "start_selected",
@@ -381,7 +381,7 @@ bool cmCPackPKGGenerator::CopyCreateResourceFile(const std::string& name,
                                                  const std::string& dirName)
 {
   std::string uname = cmSystemTools::UpperCase(name);
-  std::string cpackVar = "CPACK_RESOURCE_FILE_" + uname;
+  std::string cpackVar = cmStrCat("CPACK_RESOURCE_FILE_", uname);
   cmValue inFileName = this->GetOption(cpackVar);
   if (!inFileName) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
@@ -413,7 +413,8 @@ bool cmCPackPKGGenerator::CopyCreateResourceFile(const std::string& name,
 
   // Set this so that distribution.dist gets the right name (without
   // the path).
-  this->SetOption("CPACK_RESOURCE_FILE_" + uname + "_NOPATH", (name + ext));
+  this->SetOption(cmStrCat("CPACK_RESOURCE_FILE_", uname, "_NOPATH"),
+                  cmStrCat(name, ext));
 
   cmCPackLogger(cmCPackLog::LOG_VERBOSE,
                 "Configure file: " << (inFileName ? *inFileName : "(NULL)")
diff --git a/Source/CPack/cmCPackProductBuildGenerator.cxx b/Source/CPack/cmCPackProductBuildGenerator.cxx
index 4ad616d..843219d 100644
--- a/Source/CPack/cmCPackProductBuildGenerator.cxx
+++ b/Source/CPack/cmCPackProductBuildGenerator.cxx
@@ -58,7 +58,7 @@ int cmCPackProductBuildGenerator::PackageFiles()
     }
   }
 
-  std::string resDir = packageDirFileName + "/Contents";
+  std::string resDir = cmStrCat(packageDirFileName, "/Contents");
 
   if (this->IsSet("CPACK_PRODUCTBUILD_RESOURCES_DIR")) {
     std::string userResDir =
@@ -106,10 +106,14 @@ int cmCPackProductBuildGenerator::PackageFiles()
          << "\""
          << " --resources \"" << resDir << "\""
          << " --version \"" << version << "\""
-         << (identifier.empty() ? "" : " --identifier \"" + identifier + "\"")
-         << (identityName.empty() ? "" : " --sign \"" + identityName + "\"")
-         << (keychainPath.empty() ? ""
-                                  : " --keychain \"" + keychainPath + "\"")
+         << (identifier.empty()
+               ? std::string{}
+               : cmStrCat(" --identifier \"", identifier, '"'))
+         << (identityName.empty() ? std::string{}
+                                  : cmStrCat(" --sign \"", identityName, '"'))
+         << (keychainPath.empty()
+               ? std::string{}
+               : cmStrCat(" --keychain \"", keychainPath, '"'))
          << " \"" << packageFileNames[0] << "\"";
 
   // Run ProductBuild
@@ -187,7 +191,7 @@ bool cmCPackProductBuildGenerator::GenerateComponentPackage(
     resDir += "/";
     resDir += component->Name;
   }
-  std::string scriptDir = resDir + "/scripts";
+  std::string scriptDir = cmStrCat(resDir, "/scripts");
 
   if (!cmsys::SystemTools::MakeDirectory(scriptDir.c_str())) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
@@ -237,9 +241,11 @@ bool cmCPackProductBuildGenerator::GenerateComponentPackage(
          << " --scripts \"" << scriptDir << "\""
          << " --version \"" << version << "\""
          << " --install-location \"/\""
-         << (identityName.empty() ? "" : " --sign \"" + identityName + "\"")
-         << (keychainPath.empty() ? ""
-                                  : " --keychain \"" + keychainPath + "\"")
+         << (identityName.empty() ? std::string{}
+                                  : cmStrCat(" --sign \"", identityName, "\""))
+         << (keychainPath.empty()
+               ? std::string{}
+               : cmStrCat(" --keychain \"", keychainPath, "\""))
          << " \"" << packageFile << "\"";
 
   if (component && !component->Plist.empty()) {
@@ -253,7 +259,7 @@ bool cmCPackProductBuildGenerator::GenerateComponentPackage(
 cmValue cmCPackProductBuildGenerator::GetComponentScript(
   const char* script, const char* component_name)
 {
-  std::string scriptname = std::string("CPACK_") + script + "_";
+  std::string scriptname = cmStrCat("CPACK_", script, "_");
   if (component_name) {
     scriptname += cmSystemTools::UpperCase(component_name);
     scriptname += "_";
diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx
index f1131fe..b7766dc 100644
--- a/Source/cmGlobalXCodeGenerator.cxx
+++ b/Source/cmGlobalXCodeGenerator.cxx
@@ -226,7 +226,8 @@ cmGlobalXCodeGenerator::Factory::CreateGlobalGenerator(const std::string& name,
     if (commandResult) {
       std::string::size_type pos = out.find(".app/");
       if (pos != std::string::npos) {
-        versionFile = out.substr(0, pos + 5) + "Contents/version.plist";
+        versionFile =
+          cmStrCat(out.substr(0, pos + 5), "Contents/version.plist");
       }
     }
   }
@@ -248,7 +249,7 @@ cmGlobalXCodeGenerator::Factory::CreateGlobalGenerator(const std::string& name,
 
   if (version_number < 50) {
     cm->IssueMessage(MessageType::FATAL_ERROR,
-                     "Xcode " + version_string + " not supported.");
+                     cmStrCat("Xcode ", version_string, " not supported."));
     return std::unique_ptr<cmGlobalGenerator>();
   }
 
@@ -450,7 +451,7 @@ bool cmGlobalXCodeGenerator::Open(const std::string& bindir,
   bool ret = false;
 
 #ifdef HAVE_APPLICATION_SERVICES
-  std::string url = bindir + "/" + projectName + ".xcodeproj";
+  std::string url = cmStrCat(bindir, "/", projectName, ".xcodeproj");
 
   if (dryRun) {
     return cmSystemTools::FileExists(url, false);
@@ -852,10 +853,7 @@ cmXCodeObject* cmGlobalXCodeGenerator::CreateFlatClone(cmXCodeObject* orig)
 static std::string GetGroupMapKeyFromPath(cmGeneratorTarget* target,
                                           const std::string& fullpath)
 {
-  std::string key(target->GetName());
-  key += "-";
-  key += fullpath;
-  return key;
+  return cmStrCat(target->GetName(), "-", fullpath);
 }
 
 cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeBuildFileFromPath(
@@ -943,10 +941,10 @@ cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeSourceFile(
   std::string const& srcfmt = sf->GetSafeProperty("Fortran_FORMAT");
   switch (cmOutputConverter::GetFortranFormat(srcfmt)) {
     case cmOutputConverter::FortranFormatFixed:
-      flags = "-fixed " + flags;
+      flags = cmStrCat("-fixed ", flags);
       break;
     case cmOutputConverter::FortranFormatFree:
-      flags = "-free " + flags;
+      flags = cmStrCat("-free ", flags);
       break;
     default:
       break;
@@ -1278,7 +1276,7 @@ cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeFileReferenceFromPath(
     this->GroupMap[key] = group;
   }
   if (!group) {
-    cmSystemTools::Error("Could not find a PBX group for " + key);
+    cmSystemTools::Error(cmStrCat("Could not find a PBX group for ", key));
     return nullptr;
   }
   cmXCodeObject* children = group->GetAttribute("children");
@@ -2202,10 +2200,10 @@ void cmGlobalXCodeGenerator::AddCommandsToBuildPhase(
 
   std::string cdir = this->CurrentLocalGenerator->GetCurrentBinaryDirectory();
   cdir = this->ConvertToRelativeForMake(cdir);
-  std::string makecmd =
-    cmStrCat("make -C ", cdir, " -f ",
-             this->ConvertToRelativeForMake((makefile + "$CONFIGURATION")),
-             " OBJDIR=$(basename \"$OBJECT_FILE_DIR_normal\") all");
+  std::string makecmd = cmStrCat(
+    "make -C ", cdir, " -f ",
+    this->ConvertToRelativeForMake(cmStrCat(makefile, "$CONFIGURATION")),
+    " OBJDIR=$(basename \"$OBJECT_FILE_DIR_normal\") all");
   buildphase->AddAttribute("shellScript", this->CreateString(makecmd));
   buildphase->AddAttribute("showEnvVarsInLog", this->CreateString("0"));
 }
@@ -2243,7 +2241,7 @@ void cmGlobalXCodeGenerator::CreateCustomRulesMakefile(
       } else {
         std::ostringstream str;
         str << "_buildpart_" << count++;
-        tname[&ccg.GetCC()] = target->GetName() + str.str();
+        tname[&ccg.GetCC()] = cmStrCat(target->GetName(), str.str());
         makefileStream << "\\\n\t" << tname[&ccg.GetCC()];
       }
     }
@@ -2407,8 +2405,8 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
   std::string llang = gtgt->GetLinkerLanguage(configName);
   if (binary && llang.empty()) {
     cmSystemTools::Error(
-      "CMake can not determine linker language for target: " +
-      gtgt->GetName());
+      cmStrCat("CMake can not determine linker language for target: ",
+               gtgt->GetName()));
     return;
   }
 
@@ -2472,7 +2470,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
       std::set<std::string> defines(targetSwiftDefines.begin(),
                                     targetSwiftDefines.end());
       this->CurrentLocalGenerator->JoinDefines(defines, defineString, "Swift");
-      cflags["Swift"] += " " + defineString;
+      cflags["Swift"] += cmStrCat(" ", defineString);
     } else {
       BuildObjectListOrString swiftDefs(this, true);
       this->AppendDefines(swiftDefs, targetSwiftDefines);
@@ -2831,7 +2829,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
         includes, gtgt, language, configName);
 
       if (!includeFlags.empty()) {
-        cflags[language] += " " + includeFlags;
+        cflags[language] += cmStrCat(" ", includeFlags);
       }
     }
   }
@@ -2909,7 +2907,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
                               this->CreateString("NO"));
 
   for (auto const& language : languages) {
-    std::string flags = cflags[language] + " " + defFlags;
+    std::string flags = cmStrCat(cflags[language], " ", defFlags);
     if (language == "CXX" || language == "OBJCXX") {
       if (language == "CXX" ||
           !buildSettings->GetAttribute("OTHER_CPLUSPLUSFLAGS")) {
@@ -3459,8 +3457,8 @@ void cmGlobalXCodeGenerator::AppendBuildSettingAttribute(
 {
   if (value->GetType() != cmXCodeObject::OBJECT_LIST &&
       value->GetType() != cmXCodeObject::STRING) {
-    cmSystemTools::Error("Unsupported value type for appending: " +
-                         std::string(attribute));
+    cmSystemTools::Error(
+      cmStrCat("Unsupported value type for appending: ", attribute));
     return;
   }
   if (attr->GetType() == cmXCodeObject::OBJECT_LIST) {
@@ -3483,8 +3481,8 @@ void cmGlobalXCodeGenerator::AppendBuildSettingAttribute(
       attr->SetString(newValue);
     }
   } else {
-    cmSystemTools::Error("Unsupported attribute type for appending: " +
-                         std::string(attribute));
+    cmSystemTools::Error(
+      cmStrCat("Unsupported attribute type for appending: ", attribute));
   }
 }
 
@@ -3581,8 +3579,8 @@ void cmGlobalXCodeGenerator::AddDependAndLinkInformation(cmXCodeObject* target)
       useLinkPhase = true;
       forceLinkPhase = true;
     } else if (*prop != "NONE") {
-      cmSystemTools::Error("Invalid value for XCODE_LINK_BUILD_PHASE_MODE: " +
-                           *prop);
+      cmSystemTools::Error(
+        cmStrCat("Invalid value for XCODE_LINK_BUILD_PHASE_MODE: ", *prop));
       return;
     }
   }
@@ -3874,8 +3872,8 @@ void cmGlobalXCodeGenerator::AddDependAndLinkInformation(cmXCodeObject* target)
           cmPolicies::PolicyStatus cmp0142 =
             target->GetTarget()->GetPolicyStatusCMP0142();
           if (cmp0142 == cmPolicies::OLD || cmp0142 == cmPolicies::WARN) {
-            libSearchPaths.Add(this->XCodeEscapePath(
-              libDir + "/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)"));
+            libSearchPaths.Add(this->XCodeEscapePath(cmStrCat(
+              libDir, "/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)")));
           }
           libSearchPaths.Add(this->XCodeEscapePath(libDir));
         }
@@ -4087,16 +4085,16 @@ void cmGlobalXCodeGenerator::AddEmbeddedObjects(
       // This is a target - get it's product path reference
       auto* xcTarget = this->FindXCodeTarget(genTarget);
       if (!xcTarget) {
-        cmSystemTools::Error("Can not find a target for " +
-                             genTarget->GetName());
+        cmSystemTools::Error(
+          cmStrCat("Can not find a target for ", genTarget->GetName()));
         continue;
       }
       // Add the target output file as a build reference for other targets
       // to link against
       auto* fileRefObject = xcTarget->GetAttribute("productReference");
       if (!fileRefObject) {
-        cmSystemTools::Error("Target " + genTarget->GetName() +
-                             " is missing product reference");
+        cmSystemTools::Error(cmStrCat("Target ", genTarget->GetName(),
+                                      " is missing product reference"));
         continue;
       }
       auto it = this->FileRefToEmbedBuildFileMap.find(fileRefObject);
@@ -4121,7 +4119,8 @@ void cmGlobalXCodeGenerator::AddEmbeddedObjects(
                                   this->CreateObjectReference(fileRef));
         }
         if (!buildFile) {
-          cmSystemTools::Error("Can't create build file for " + relFile);
+          cmSystemTools::Error(
+            cmStrCat("Can't create build file for ", relFile));
           continue;
         }
         this->EmbeddedLibRefs.emplace(filePath, buildFile);
@@ -4130,7 +4129,7 @@ void cmGlobalXCodeGenerator::AddEmbeddedObjects(
       }
     }
     if (!buildFile) {
-      cmSystemTools::Error("Can't find a build file for " + relFile);
+      cmSystemTools::Error(cmStrCat("Can't find a build file for ", relFile));
       continue;
     }
     // Set build file configuration
@@ -4689,7 +4688,8 @@ void cmGlobalXCodeGenerator::CreateXCodeDependHackMakefile(
 {
   cmGeneratedFileStream makefileStream(this->CurrentXCodeHackMakefile);
   if (!makefileStream) {
-    cmSystemTools::Error("Could not create " + this->CurrentXCodeHackMakefile);
+    cmSystemTools::Error(
+      cmStrCat("Could not create ", this->CurrentXCodeHackMakefile));
     return;
   }
   makefileStream.SetCopyIfDifferent(true);
@@ -4817,7 +4817,7 @@ void cmGlobalXCodeGenerator::OutputXCodeProject(
   std::string xcodeDir = cmStrCat(root->GetCurrentBinaryDirectory(), '/',
                                   root->GetProjectName(), ".xcodeproj");
   cmSystemTools::MakeDirectory(xcodeDir);
-  std::string xcodeProjFile = xcodeDir + "/project.pbxproj";
+  std::string xcodeProjFile = cmStrCat(xcodeDir, "/project.pbxproj");
   cmGeneratedFileStream fout(xcodeProjFile);
   fout.SetCopyIfDifferent(true);
   if (!fout) {
diff --git a/Source/cmXCodeScheme.cxx b/Source/cmXCodeScheme.cxx
index 217ac61..0019278 100644
--- a/Source/cmXCodeScheme.cxx
+++ b/Source/cmXCodeScheme.cxx
@@ -447,7 +447,7 @@ void cmXCodeScheme::WriteBuildableReference(cmXMLWriter& xout,
   std::string const noConfig; // FIXME: What config to use here?
   xout.Attribute("BuildableName", xcObj->GetTarget()->GetFullName(noConfig));
   xout.Attribute("BlueprintName", xcObj->GetTarget()->GetName());
-  xout.Attribute("ReferencedContainer", "container:" + container);
+  xout.Attribute("ReferencedContainer", cmStrCat("container:", container));
   xout.EndElement();
 }