cmState::GetTargetTypeName: return type is *cmProp

Source/cmCoreTryCompile.cxx

@@ -101,29 +101,23 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
   this->SrcFileSignature = true;
 
   cmStateEnums::TargetType targetType = cmStateEnums::EXECUTABLE;
-  const char* tt =
+  const std::string* tt =
-    this->Makefile->GetDefinition("CMAKE_TRY_COMPILE_TARGET_TYPE");
+    this->Makefile->GetDef("CMAKE_TRY_COMPILE_TARGET_TYPE");
-  if (!isTryRun && tt && *tt) {
+  if (!isTryRun && tt && !tt->empty()) {
-    if (strcmp(tt, cmState::GetTargetTypeName(cmStateEnums::EXECUTABLE)) ==
+    if (*tt == cmState::GetTargetTypeName(cmStateEnums::EXECUTABLE)) {
-        0) {
       targetType = cmStateEnums::EXECUTABLE;
-    } else if (strcmp(tt,
+    } else if (*tt ==
-                      cmState::GetTargetTypeName(
+               cmState::GetTargetTypeName(cmStateEnums::STATIC_LIBRARY)) {
-                        cmStateEnums::STATIC_LIBRARY)) == 0) {
       targetType = cmStateEnums::STATIC_LIBRARY;
     } else {
       this->Makefile->IssueMessage(
         MessageType::FATAL_ERROR,
-        std::string("Invalid value '") + tt +
+        cmStrCat("Invalid value '", *tt,
-          "' for "
+                 "' for CMAKE_TRY_COMPILE_TARGET_TYPE.  Only '",
-          "CMAKE_TRY_COMPILE_TARGET_TYPE.  Only "
+                 cmState::GetTargetTypeName(cmStateEnums::EXECUTABLE),
-          "'" +
+                 "' and '",
-          cmState::GetTargetTypeName(cmStateEnums::EXECUTABLE) +
+                 cmState::GetTargetTypeName(cmStateEnums::STATIC_LIBRARY),
-          "' and "
+                 "' are allowed."));
-          "'" +
-          cmState::GetTargetTypeName(cmStateEnums::STATIC_LIBRARY) +
-          "' "
-          "are allowed.");
       return -1;
     }
   }
@@ -296,12 +290,10 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
           default:
             this->Makefile->IssueMessage(
               MessageType::FATAL_ERROR,
-              "Only libraries may be used as try_compile or try_run IMPORTED "
+              cmStrCat("Only libraries may be used as try_compile or try_run "
-              "LINK_LIBRARIES.  Got " +
+                       "IMPORTED LINK_LIBRARIES.  Got ",
-                std::string(tgt->GetName()) +
+                       tgt->GetName(), " of type ",
-                " of "
+                       cmState::GetTargetTypeName(tgt->GetType()), "."));
-                "type " +
-                cmState::GetTargetTypeName(tgt->GetType()) + ".");
             return -1;
         }
         if (tgt->IsImported()) {

Source/cmLocalUnixMakefileGenerator3.cxx

@@ -974,7 +974,8 @@ void cmLocalUnixMakefileGenerator3::AppendCustomCommand(
         // Expand rule variables referenced in the given launcher command.
         cmRulePlaceholderExpander::RuleVariables vars;
         vars.CMTargetName = target->GetName().c_str();
-        vars.CMTargetType = cmState::GetTargetTypeName(target->GetType());
+        vars.CMTargetType =
+          cmState::GetTargetTypeName(target->GetType()).c_str();
         std::string output;
         const std::vector<std::string>& outputs = ccg.GetOutputs();
         if (!outputs.empty()) {

Source/cmMakefileExecutableTargetGenerator.cxx

@@ -547,7 +547,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
     cmRulePlaceholderExpander::RuleVariables vars;
     vars.CMTargetName = this->GeneratorTarget->GetName().c_str();
     vars.CMTargetType =
-      cmState::GetTargetTypeName(this->GeneratorTarget->GetType());
+      cmState::GetTargetTypeName(this->GeneratorTarget->GetType()).c_str();
     vars.Language = linkLanguage.c_str();
     vars.Objects = buildObjs.c_str();
     std::string objectDir = this->GeneratorTarget->GetSupportDirectory();

Source/cmMakefileLibraryTargetGenerator.cxx

@@ -756,7 +756,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
 
     vars.CMTargetName = this->GeneratorTarget->GetName().c_str();
     vars.CMTargetType =
-      cmState::GetTargetTypeName(this->GeneratorTarget->GetType());
+      cmState::GetTargetTypeName(this->GeneratorTarget->GetType()).c_str();
     vars.Language = linkLanguage.c_str();
     vars.AIXExports = aixExports.c_str();
     vars.Objects = buildObjs.c_str();

Source/cmMakefileTargetGenerator.cxx

@@ -639,7 +639,7 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
   cmRulePlaceholderExpander::RuleVariables vars;
   vars.CMTargetName = this->GeneratorTarget->GetName().c_str();
   vars.CMTargetType =
-    cmState::GetTargetTypeName(this->GeneratorTarget->GetType());
+    cmState::GetTargetTypeName(this->GeneratorTarget->GetType()).c_str();
   vars.Language = lang.c_str();
   vars.Target = targetOutPathReal.c_str();
   vars.TargetPDB = targetOutPathPDB.c_str();

Source/cmNinjaNormalTargetGenerator.cxx

@@ -156,23 +156,25 @@ const char* cmNinjaNormalTargetGenerator::GetVisibleTypeName() const
 std::string cmNinjaNormalTargetGenerator::LanguageLinkerRule(
   const std::string& config) const
 {
-  return this->TargetLinkLanguage(config) + "_" +
+  return cmStrCat(
-    cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()) +
+    this->TargetLinkLanguage(config), "_",
-    "_LINKER__" +
+    cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()),
+    "_LINKER__",
     cmGlobalNinjaGenerator::EncodeRuleName(
-           this->GetGeneratorTarget()->GetName()) +
+      this->GetGeneratorTarget()->GetName()),
-    "_" + config;
+    "_", config);
 }
 
 std::string cmNinjaNormalTargetGenerator::LanguageLinkerDeviceRule(
   const std::string& config) const
 {
-  return this->TargetLinkLanguage(config) + "_" +
+  return cmStrCat(
-    cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()) +
+    this->TargetLinkLanguage(config), "_",
-    "_DEVICE_LINKER__" +
+    cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()),
+    "_DEVICE_LINKER__",
     cmGlobalNinjaGenerator::EncodeRuleName(
-           this->GetGeneratorTarget()->GetName()) +
+      this->GetGeneratorTarget()->GetName()),
-    "_" + config;
+    "_", config);
 }
 
 struct cmNinjaRemoveNoOpCommands
@@ -191,7 +193,8 @@ void cmNinjaNormalTargetGenerator::WriteDeviceLinkRule(
     cmRulePlaceholderExpander::RuleVariables vars;
     vars.CMTargetName = this->GetGeneratorTarget()->GetName().c_str();
     vars.CMTargetType =
-      cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType());
+      cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType())
+        .c_str();
 
     vars.Language = "CUDA";
 
@@ -282,7 +285,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkRule(bool useResponseFile,
     cmNinjaRule rule(std::move(linkRuleName));
     cmRulePlaceholderExpander::RuleVariables vars;
     vars.CMTargetName = this->GetGeneratorTarget()->GetName().c_str();
-    vars.CMTargetType = cmState::GetTargetTypeName(targetType);
+    vars.CMTargetType = cmState::GetTargetTypeName(targetType).c_str();
 
     std::string lang = this->TargetLinkLanguage(config);
     vars.Language = config.c_str();

Source/cmNinjaTargetGenerator.cxx

@@ -495,7 +495,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
   cmRulePlaceholderExpander::RuleVariables vars;
   vars.CMTargetName = this->GetGeneratorTarget()->GetName().c_str();
   vars.CMTargetType =
-    cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType());
+    cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()).c_str();
   vars.Language = lang.c_str();
   vars.Source = "$in";
   vars.Object = "$out";

Source/cmState.cxx

@@ -34,30 +34,44 @@ cmState::cmState()
 
 cmState::~cmState() = default;
 
-const char* cmState::GetTargetTypeName(cmStateEnums::TargetType targetType)
+const std::string& cmState::GetTargetTypeName(
+  cmStateEnums::TargetType targetType)
 {
+#define MAKE_STATIC_PROP(PROP) static const std::string prop##PROP = #PROP
+  MAKE_STATIC_PROP(STATIC_LIBRARY);
+  MAKE_STATIC_PROP(MODULE_LIBRARY);
+  MAKE_STATIC_PROP(SHARED_LIBRARY);
+  MAKE_STATIC_PROP(OBJECT_LIBRARY);
+  MAKE_STATIC_PROP(EXECUTABLE);
+  MAKE_STATIC_PROP(UTILITY);
+  MAKE_STATIC_PROP(GLOBAL_TARGET);
+  MAKE_STATIC_PROP(INTERFACE_LIBRARY);
+  MAKE_STATIC_PROP(UNKNOWN_LIBRARY);
+  static const std::string propEmpty;
+#undef MAKE_STATIC_PROP
+
   switch (targetType) {
     case cmStateEnums::STATIC_LIBRARY:
-      return "STATIC_LIBRARY";
+      return propSTATIC_LIBRARY;
     case cmStateEnums::MODULE_LIBRARY:
-      return "MODULE_LIBRARY";
+      return propMODULE_LIBRARY;
     case cmStateEnums::SHARED_LIBRARY:
-      return "SHARED_LIBRARY";
+      return propSHARED_LIBRARY;
     case cmStateEnums::OBJECT_LIBRARY:
-      return "OBJECT_LIBRARY";
+      return propOBJECT_LIBRARY;
     case cmStateEnums::EXECUTABLE:
-      return "EXECUTABLE";
+      return propEXECUTABLE;
     case cmStateEnums::UTILITY:
-      return "UTILITY";
+      return propUTILITY;
     case cmStateEnums::GLOBAL_TARGET:
-      return "GLOBAL_TARGET";
+      return propGLOBAL_TARGET;
     case cmStateEnums::INTERFACE_LIBRARY:
-      return "INTERFACE_LIBRARY";
+      return propINTERFACE_LIBRARY;
     case cmStateEnums::UNKNOWN_LIBRARY:
-      return "UNKNOWN_LIBRARY";
+      return propUNKNOWN_LIBRARY;
   }
   assert(false && "Unexpected target type");
-  return nullptr;
+  return propEmpty;
 }
 
 static const std::array<std::string, 7> cmCacheEntryTypes = {

Source/cmState.h

@@ -53,7 +53,8 @@ public:
     CPack,
   };
 
-  static const char* GetTargetTypeName(cmStateEnums::TargetType targetType);
+  static const std::string& GetTargetTypeName(
+    cmStateEnums::TargetType targetType);
 
   cmStateSnapshot CreateBaseSnapshot();
   cmStateSnapshot CreateBuildsystemDirectorySnapshot(

Source/cmTarget.cxx

@@ -1668,7 +1668,7 @@ const char* cmTarget::GetProperty(const std::string& prop) const
     }
     // the type property returns what type the target is
     if (prop == propTYPE) {
-      return cmState::GetTargetTypeName(this->GetType());
+      return cmState::GetTargetTypeName(this->GetType()).c_str();
     }
     if (prop == propINCLUDE_DIRECTORIES) {
       if (impl->IncludeDirectoriesEntries.empty()) {