/src/CMake/Source/cmRulePlaceholderExpander.cxx

Source
/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file LICENSE.rst or https://cmake.org/licensing for details.  */
#include "cmRulePlaceholderExpander.h"

#include <utility>

#include "cmOutputConverter.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"

cmRulePlaceholderExpander::cmRulePlaceholderExpander(
  cmBuildStep buildStep, std::map<std::string, std::string> compilers,
  std::map<std::string, std::string> variableMappings,
  std::string compilerSysroot, std::string linkerSysroot,
  UseShortPaths useShortPaths)
  : BuildStep(buildStep)
  , Compilers(std::move(compilers))
  , VariableMappings(std::move(variableMappings))
  , CompilerSysroot(std::move(compilerSysroot))
  , LinkerSysroot(std::move(linkerSysroot))
{
  if (useShortPaths == UseShortPaths::Yes) {
    this->ConvertToOutputForExisting =
      [this](cm::string_view path) -> std::string {
      return this->OutputConverter->ConvertToOutputForExisting(path);
    };
  } else {
    this->ConvertToOutputForExisting =
      [this](cm::string_view path) -> std::string {
      return this->OutputConverter->ConvertToOutputFormat(
        path, cmOutputConverter::SHELL);
    };
  }
}

std::string cmRulePlaceholderExpander::ExpandVariable(
  std::string const& variable)
{
  if (this->ReplaceValues->LinkFlags) {
    if (variable == "LINK_FLAGS") {
      return this->ReplaceValues->LinkFlags;
    }
  }
  if (this->ReplaceValues->Linker) {
    if (variable == "CMAKE_LINKER") {
      auto result =
        this->ConvertToOutputForExisting(this->ReplaceValues->Linker);
      if (this->ReplaceValues->Launcher) {
        // Add launcher as part of expansion so that it always appears
        // immediately before the command itself, regardless of whether the
        // overall rule template contains other content at the front.
        result =
          cmStrCat(this->ReplaceValues->Launcher, ' ', std::move(result));
      }
      return result;
    }
  }
  if (this->ReplaceValues->Language && this->ReplaceValues->Launcher &&
      variable ==
        cmStrCat("CMAKE_", this->ReplaceValues->Language,
                 "_HOST_LINK_LAUNCHER")) {
    auto mapIt = this->VariableMappings.find(variable);
    std::string result = mapIt != this->VariableMappings.end()
      ? this->ConvertToOutputForExisting(mapIt->second)
      : variable;
    // Add launcher as part of expansion so that it always appears
    // immediately before the command itself, regardless of whether the
    // overall rule template contains other content at the front.
    return cmStrCat(this->ReplaceValues->Launcher, ' ', result);
  }
  if (this->ReplaceValues->Manifests) {
    if (variable == "MANIFESTS") {
      return this->ReplaceValues->Manifests;
    }
  }
  if (this->ReplaceValues->Flags) {
    if (variable == "FLAGS") {
      return this->ReplaceValues->Flags;
    }
  }

  if (this->ReplaceValues->Source) {
    if (variable == "SOURCE") {
      return this->ReplaceValues->Source;
    }
  }
  if (this->ReplaceValues->DynDepFile) {
    if (variable == "DYNDEP_FILE") {
      return this->ReplaceValues->DynDepFile;
    }
  }
  if (this->ReplaceValues->PreprocessedSource) {
    if (variable == "PREPROCESSED_SOURCE") {
      return this->ReplaceValues->PreprocessedSource;
    }
  }
  if (this->ReplaceValues->AssemblySource) {
    if (variable == "ASSEMBLY_SOURCE") {
      return this->ReplaceValues->AssemblySource;
    }
  }
  if (this->ReplaceValues->Object) {
    if (variable == "OBJECT") {
      return this->ReplaceValues->Object;
    }
  }
  if (this->ReplaceValues->TargetSupportDir) {
    if (variable == "TARGET_SUPPORT_DIR") {
      return this->ReplaceValues->TargetSupportDir;
    }
  }
  if (this->ReplaceValues->ObjectDir) {
    if (variable == "OBJECT_DIR") {
      return this->ReplaceValues->ObjectDir;
    }
  }
  if (this->ReplaceValues->ObjectFileDir) {
    if (variable == "OBJECT_FILE_DIR") {
      return this->ReplaceValues->ObjectFileDir;
    }
  }
  if (this->ReplaceValues->Objects) {
    if (variable == "OBJECTS") {
      return this->ReplaceValues->Objects;
    }
  }
  if (this->ReplaceValues->ObjectsQuoted) {
    if (variable == "OBJECTS_QUOTED") {
      return this->ReplaceValues->ObjectsQuoted;
    }
  }
  if (this->ReplaceValues->CudaCompileMode) {
    if (variable == "CUDA_COMPILE_MODE") {
      return this->ReplaceValues->CudaCompileMode;
    }
  }
  if (this->ReplaceValues->AIXExports) {
    if (variable == "AIX_EXPORTS") {
      return this->ReplaceValues->AIXExports;
    }
  }
  if (this->ReplaceValues->ISPCHeader) {
    if (variable == "ISPC_HEADER") {
      return this->ReplaceValues->ISPCHeader;
    }
  }
  if (this->ReplaceValues->Defines && variable == "DEFINES") {
    return this->ReplaceValues->Defines;
  }
  if (this->ReplaceValues->Includes && variable == "INCLUDES") {
    return this->ReplaceValues->Includes;
  }
  if (this->ReplaceValues->SwiftLibraryName) {
    if (variable == "SWIFT_LIBRARY_NAME") {
      return this->ReplaceValues->SwiftLibraryName;
    }
  }
  if (this->ReplaceValues->SwiftModule) {
    if (variable == "SWIFT_MODULE") {
      return this->ReplaceValues->SwiftModule;
    }
  }
  if (this->ReplaceValues->SwiftModuleName) {
    if (variable == "SWIFT_MODULE_NAME") {
      return this->ReplaceValues->SwiftModuleName;
    }
  }
  if (this->ReplaceValues->SwiftSources) {
    if (variable == "SWIFT_SOURCES") {
      return this->ReplaceValues->SwiftSources;
    }
  }
  if (this->ReplaceValues->RustEmit) {
    if (variable == "RUST_EMIT") {
      return this->ReplaceValues->RustEmit;
    }
  }
  if (this->ReplaceValues->RustMainCrateRoot) {
    if (variable == "RUST_MAIN_CRATE_ROOT") {
      return this->ReplaceValues->RustMainCrateRoot;
    }
  }
  if (this->ReplaceValues->RustLinkCrates) {
    if (variable == "RUST_LINK_CRATES") {
      return this->ReplaceValues->RustLinkCrates;
    }
  }
  if (this->ReplaceValues->RustNativeObjects) {
    if (variable == "RUST_NATIVE_OBJECTS") {
      return this->ReplaceValues->RustNativeObjects;
    }
  }
  if (this->ReplaceValues->TargetPDB) {
    if (variable == "TARGET_PDB") {
      return this->ReplaceValues->TargetPDB;
    }
  }
  if (this->ReplaceValues->TargetCompilePDB) {
    if (variable == "TARGET_COMPILE_PDB") {
      return this->ReplaceValues->TargetCompilePDB;
    }
  }
  if (this->ReplaceValues->DependencyFile) {
    if (variable == "DEP_FILE") {
      return this->ReplaceValues->DependencyFile;
    }
  }
  if (this->ReplaceValues->DependencyTarget) {
    if (variable == "DEP_TARGET") {
      return this->ReplaceValues->DependencyTarget;
    }
  }
  if (this->ReplaceValues->Fatbinary) {
    if (variable == "FATBINARY") {
      return this->ReplaceValues->Fatbinary;
    }
  }
  if (this->ReplaceValues->RegisterFile) {
    if (variable == "REGISTER_FILE") {
      return this->ReplaceValues->RegisterFile;
    }
  }

  if (this->ReplaceValues->Target) {
    if (variable == "TARGET_QUOTED") {
      std::string targetQuoted = this->ReplaceValues->Target;
      if (!targetQuoted.empty() && targetQuoted.front() != '\"') {
        targetQuoted = cmStrCat('"', this->ReplaceValues->Target, '"');
      }
      return targetQuoted;
    }
    if (variable == "TARGET_UNQUOTED") {
      std::string unquoted = this->ReplaceValues->Target;
      std::string::size_type sz = unquoted.size();
      if (sz > 2 && unquoted.front() == '\"' && unquoted.back() == '\"') {
        unquoted = unquoted.substr(1, sz - 2);
      }
      return unquoted;
    }
    if (this->ReplaceValues->LanguageCompileFlags) {
      if (variable == "LANGUAGE_COMPILE_FLAGS") {
        return this->ReplaceValues->LanguageCompileFlags;
      }
    }
    if (this->ReplaceValues->Target) {
      if (variable == "TARGET") {
        return this->ReplaceValues->Target;
      }
    }
    if (variable == "TARGET_IMPLIB") {
      return this->TargetImpLib;
    }
    if (variable == "TARGET_VERSION_MAJOR") {
      if (this->ReplaceValues->TargetVersionMajor) {
        return this->ReplaceValues->TargetVersionMajor;
      }
      return "0";
    }
    if (variable == "TARGET_VERSION_MINOR") {
      if (this->ReplaceValues->TargetVersionMinor) {
        return this->ReplaceValues->TargetVersionMinor;
      }
      return "0";
    }
    if (this->ReplaceValues->Target) {
      if (variable == "TARGET_BASE") {
        // Strip the last extension off the target name.
        std::string targetBase = this->ReplaceValues->Target;
        std::string::size_type pos = targetBase.rfind('.');
        if (pos != std::string::npos) {
          return targetBase.substr(0, pos);
        }
        return targetBase;
      }
    }
  }
  if (variable == "TARGET_SONAME" || variable == "SONAME_FLAG" ||
      variable == "TARGET_INSTALLNAME_DIR") {
    // All these variables depend on TargetSOName
    if (this->ReplaceValues->TargetSOName) {
      if (variable == "TARGET_SONAME") {
        return this->ReplaceValues->TargetSOName;
      }
      if (variable == "SONAME_FLAG" && this->ReplaceValues->SONameFlag) {
        return this->ReplaceValues->SONameFlag;
      }
      if (this->ReplaceValues->TargetInstallNameDir &&
          variable == "TARGET_INSTALLNAME_DIR") {
        return this->ReplaceValues->TargetInstallNameDir;
      }
    }
    return "";
  }
  if (this->ReplaceValues->LinkLibraries) {
    if (variable == "LINK_LIBRARIES") {
      return this->ReplaceValues->LinkLibraries;
    }
  }
  if (this->ReplaceValues->Language) {
    if (variable == "LANGUAGE") {
      return this->ReplaceValues->Language;
    }
  }
  if (this->ReplaceValues->CMTargetName) {
    if (variable == "TARGET_NAME") {
      return this->ReplaceValues->CMTargetName;
    }
  }
  if (this->ReplaceValues->CMTargetType) {
    if (variable == "TARGET_TYPE") {
      return this->ReplaceValues->CMTargetType;
    }
  }
  if (this->ReplaceValues->Output) {
    if (variable == "OUTPUT") {
      return this->ReplaceValues->Output;
    }
  }
  if (this->ReplaceValues->FilePathWithOutput) {
    if (variable == "OUTPUT_STORE_TO_FILE") {
      return this->ReplaceValues->FilePathWithOutput;
    }
  }
  if (variable == "CMAKE_COMMAND") {
    return this->OutputConverter->ConvertToOutputFormat(
      cmSystemTools::GetCMakeCommand(), cmOutputConverter::SHELL);
  }
  if (variable == "ROLE") {
    if (this->ReplaceValues->Role) {
      return this->ReplaceValues->Role;
    }
    return "";
  }
  if (variable == "CONFIG") {
    if (this->ReplaceValues->Config) {
      return this->ReplaceValues->Config;
    }
    return "";
  }

  auto compIt = this->Compilers.find(variable);

  if (compIt != this->Compilers.end()) {
    std::string const& compilerPath =
      this->VariableMappings[cmStrCat("CMAKE_", compIt->second, "_COMPILER")];
    std::string ret = this->ConvertToOutputForExisting(compilerPath);
    std::string const& compilerArg1 = this->VariableMappings[cmStrCat(
      "CMAKE_", compIt->second, "_COMPILER_ARG1")];
    std::string const& compilerTarget = this->VariableMappings[cmStrCat(
      "CMAKE_", compIt->second, "_COMPILER_TARGET")];
    std::string const& compilerOptionTarget = this->VariableMappings[cmStrCat(
      "CMAKE_", compIt->second, "_COMPILE_OPTIONS_TARGET")];
    std::string const& compilerExternalToolchain =
      this->VariableMappings[cmStrCat("CMAKE_", compIt->second,
                                      "_COMPILER_EXTERNAL_TOOLCHAIN")];
    std::string const& compilerOptionExternalToolchain =
      this->VariableMappings[cmStrCat("CMAKE_", compIt->second,
                                      "_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN")];
    std::string const& compilerOptionSysroot = this->VariableMappings[cmStrCat(
      "CMAKE_", compIt->second, "_COMPILE_OPTIONS_SYSROOT")];

    if (compIt->second == this->ReplaceValues->Language &&
        this->ReplaceValues->Launcher) {
      // Add launcher as part of expansion so that it always appears
      // immediately before the command itself, regardless of whether the
      // overall rule template contains other content at the front.
      ret = cmStrCat(this->ReplaceValues->Launcher, ' ', std::move(ret));
    }

    // if there are required arguments to the compiler add it
    // to the compiler string
    if (!compilerArg1.empty()) {
      ret = cmStrCat(std::move(ret), ' ', compilerArg1);
    }
    if (!compilerTarget.empty() && !compilerOptionTarget.empty()) {
      ret =
        cmStrCat(std::move(ret), ' ', compilerOptionTarget, compilerTarget);
    }
    if (!compilerExternalToolchain.empty() &&
        !compilerOptionExternalToolchain.empty()) {
      ret = cmStrCat(std::move(ret), ' ', compilerOptionExternalToolchain,
                     this->OutputConverter->EscapeForShell(
                       compilerExternalToolchain, true));
    }
    std::string sysroot;
    // Some platforms may use separate sysroots for compiling and linking.
    // When the build step is link, pass the link sysroot instead.
    if (this->BuildStep == cmBuildStep::Link) {
      sysroot = this->LinkerSysroot;
    } else {
      sysroot = this->CompilerSysroot;
    }
    if (!sysroot.empty() && !compilerOptionSysroot.empty()) {
      ret = cmStrCat(std::move(ret), ' ', compilerOptionSysroot,
                     this->OutputConverter->EscapeForShell(sysroot, true));
    }
    return ret;
  }

  auto mapIt = this->VariableMappings.find(variable);
  if (mapIt != this->VariableMappings.end()) {
    if (variable.find("_FLAG") == std::string::npos) {
      return this->ConvertToOutputForExisting(mapIt->second);
    }
    return mapIt->second;
  }
  return variable;
}

void cmRulePlaceholderExpander::ExpandRuleVariables(
  cmOutputConverter* outputConverter, std::string& s,
  RuleVariables const& replaceValues)
{
  this->OutputConverter = outputConverter;
  this->ReplaceValues = &replaceValues;

  this->ExpandVariables(s);
}

Coverage Report

Created: 2026-10-28 06:38

Line	Count	Source
1		/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
2		file LICENSE.rst or https://cmake.org/licensing for details. */
3		#include "cmRulePlaceholderExpander.h"
4
5		#include <utility>
6
7		#include "cmOutputConverter.h"
8		#include "cmStringAlgorithms.h"
9		#include "cmSystemTools.h"
10
11		cmRulePlaceholderExpander::cmRulePlaceholderExpander(
12		cmBuildStep buildStep, std::map<std::string, std::string> compilers,
13		std::map<std::string, std::string> variableMappings,
14		std::string compilerSysroot, std::string linkerSysroot,
15		UseShortPaths useShortPaths)
16	0	: BuildStep(buildStep)
17	0	, Compilers(std::move(compilers))
18	0	, VariableMappings(std::move(variableMappings))
19	0	, CompilerSysroot(std::move(compilerSysroot))
20	0	, LinkerSysroot(std::move(linkerSysroot))
21	0	{
22	0	if (useShortPaths == UseShortPaths::Yes) {
23	0	this->ConvertToOutputForExisting =
24	0	[this](cm::string_view path) -> std::string {
25	0	return this->OutputConverter->ConvertToOutputForExisting(path);
26	0	};
27	0	} else {
28	0	this->ConvertToOutputForExisting =
29	0	[this](cm::string_view path) -> std::string {
30	0	return this->OutputConverter->ConvertToOutputFormat(
31	0	path, cmOutputConverter::SHELL);
32	0	};
33	0	}
34	0	}
35
36		std::string cmRulePlaceholderExpander::ExpandVariable(
37		std::string const& variable)
38	0	{
39	0	if (this->ReplaceValues->LinkFlags) {
40	0	if (variable == "LINK_FLAGS") {
41	0	return this->ReplaceValues->LinkFlags;
42	0	}
43	0	}
44	0	if (this->ReplaceValues->Linker) {
45	0	if (variable == "CMAKE_LINKER") {
46	0	auto result =
47	0	this->ConvertToOutputForExisting(this->ReplaceValues->Linker);
48	0	if (this->ReplaceValues->Launcher) {
49		// Add launcher as part of expansion so that it always appears
50		// immediately before the command itself, regardless of whether the
51		// overall rule template contains other content at the front.
52	0	result =
53	0	cmStrCat(this->ReplaceValues->Launcher, ' ', std::move(result));
54	0	}
55	0	return result;
56	0	}
57	0	}
58	0	if (this->ReplaceValues->Language && this->ReplaceValues->Launcher &&
59	0	variable ==
60	0	cmStrCat("CMAKE_", this->ReplaceValues->Language,
61	0	"_HOST_LINK_LAUNCHER")) {
62	0	auto mapIt = this->VariableMappings.find(variable);
63	0	std::string result = mapIt != this->VariableMappings.end()
64	0	? this->ConvertToOutputForExisting(mapIt->second)
65	0	: variable;
66		// Add launcher as part of expansion so that it always appears
67		// immediately before the command itself, regardless of whether the
68		// overall rule template contains other content at the front.
69	0	return cmStrCat(this->ReplaceValues->Launcher, ' ', result);
70	0	}
71	0	if (this->ReplaceValues->Manifests) {
72	0	if (variable == "MANIFESTS") {
73	0	return this->ReplaceValues->Manifests;
74	0	}
75	0	}
76	0	if (this->ReplaceValues->Flags) {
77	0	if (variable == "FLAGS") {
78	0	return this->ReplaceValues->Flags;
79	0	}
80	0	}
81
82	0	if (this->ReplaceValues->Source) {
83	0	if (variable == "SOURCE") {
84	0	return this->ReplaceValues->Source;
85	0	}
86	0	}
87	0	if (this->ReplaceValues->DynDepFile) {
88	0	if (variable == "DYNDEP_FILE") {
89	0	return this->ReplaceValues->DynDepFile;
90	0	}
91	0	}
92	0	if (this->ReplaceValues->PreprocessedSource) {
93	0	if (variable == "PREPROCESSED_SOURCE") {
94	0	return this->ReplaceValues->PreprocessedSource;
95	0	}
96	0	}
97	0	if (this->ReplaceValues->AssemblySource) {
98	0	if (variable == "ASSEMBLY_SOURCE") {
99	0	return this->ReplaceValues->AssemblySource;
100	0	}
101	0	}
102	0	if (this->ReplaceValues->Object) {
103	0	if (variable == "OBJECT") {
104	0	return this->ReplaceValues->Object;
105	0	}
106	0	}
107	0	if (this->ReplaceValues->TargetSupportDir) {
108	0	if (variable == "TARGET_SUPPORT_DIR") {
109	0	return this->ReplaceValues->TargetSupportDir;
110	0	}
111	0	}
112	0	if (this->ReplaceValues->ObjectDir) {
113	0	if (variable == "OBJECT_DIR") {
114	0	return this->ReplaceValues->ObjectDir;
115	0	}
116	0	}
117	0	if (this->ReplaceValues->ObjectFileDir) {
118	0	if (variable == "OBJECT_FILE_DIR") {
119	0	return this->ReplaceValues->ObjectFileDir;
120	0	}
121	0	}
122	0	if (this->ReplaceValues->Objects) {
123	0	if (variable == "OBJECTS") {
124	0	return this->ReplaceValues->Objects;
125	0	}
126	0	}
127	0	if (this->ReplaceValues->ObjectsQuoted) {
128	0	if (variable == "OBJECTS_QUOTED") {
129	0	return this->ReplaceValues->ObjectsQuoted;
130	0	}
131	0	}
132	0	if (this->ReplaceValues->CudaCompileMode) {
133	0	if (variable == "CUDA_COMPILE_MODE") {
134	0	return this->ReplaceValues->CudaCompileMode;
135	0	}
136	0	}
137	0	if (this->ReplaceValues->AIXExports) {
138	0	if (variable == "AIX_EXPORTS") {
139	0	return this->ReplaceValues->AIXExports;
140	0	}
141	0	}
142	0	if (this->ReplaceValues->ISPCHeader) {
143	0	if (variable == "ISPC_HEADER") {
144	0	return this->ReplaceValues->ISPCHeader;
145	0	}
146	0	}
147	0	if (this->ReplaceValues->Defines && variable == "DEFINES") {
148	0	return this->ReplaceValues->Defines;
149	0	}
150	0	if (this->ReplaceValues->Includes && variable == "INCLUDES") {
151	0	return this->ReplaceValues->Includes;
152	0	}
153	0	if (this->ReplaceValues->SwiftLibraryName) {
154	0	if (variable == "SWIFT_LIBRARY_NAME") {
155	0	return this->ReplaceValues->SwiftLibraryName;
156	0	}
157	0	}
158	0	if (this->ReplaceValues->SwiftModule) {
159	0	if (variable == "SWIFT_MODULE") {
160	0	return this->ReplaceValues->SwiftModule;
161	0	}
162	0	}
163	0	if (this->ReplaceValues->SwiftModuleName) {
164	0	if (variable == "SWIFT_MODULE_NAME") {
165	0	return this->ReplaceValues->SwiftModuleName;
166	0	}
167	0	}
168	0	if (this->ReplaceValues->SwiftSources) {
169	0	if (variable == "SWIFT_SOURCES") {
170	0	return this->ReplaceValues->SwiftSources;
171	0	}
172	0	}
173	0	if (this->ReplaceValues->RustEmit) {
174	0	if (variable == "RUST_EMIT") {
175	0	return this->ReplaceValues->RustEmit;
176	0	}
177	0	}
178	0	if (this->ReplaceValues->RustMainCrateRoot) {
179	0	if (variable == "RUST_MAIN_CRATE_ROOT") {
180	0	return this->ReplaceValues->RustMainCrateRoot;
181	0	}
182	0	}
183	0	if (this->ReplaceValues->RustLinkCrates) {
184	0	if (variable == "RUST_LINK_CRATES") {
185	0	return this->ReplaceValues->RustLinkCrates;
186	0	}
187	0	}
188	0	if (this->ReplaceValues->RustNativeObjects) {
189	0	if (variable == "RUST_NATIVE_OBJECTS") {
190	0	return this->ReplaceValues->RustNativeObjects;
191	0	}
192	0	}
193	0	if (this->ReplaceValues->TargetPDB) {
194	0	if (variable == "TARGET_PDB") {
195	0	return this->ReplaceValues->TargetPDB;
196	0	}
197	0	}
198	0	if (this->ReplaceValues->TargetCompilePDB) {
199	0	if (variable == "TARGET_COMPILE_PDB") {
200	0	return this->ReplaceValues->TargetCompilePDB;
201	0	}
202	0	}
203	0	if (this->ReplaceValues->DependencyFile) {
204	0	if (variable == "DEP_FILE") {
205	0	return this->ReplaceValues->DependencyFile;
206	0	}
207	0	}
208	0	if (this->ReplaceValues->DependencyTarget) {
209	0	if (variable == "DEP_TARGET") {
210	0	return this->ReplaceValues->DependencyTarget;
211	0	}
212	0	}
213	0	if (this->ReplaceValues->Fatbinary) {
214	0	if (variable == "FATBINARY") {
215	0	return this->ReplaceValues->Fatbinary;
216	0	}
217	0	}
218	0	if (this->ReplaceValues->RegisterFile) {
219	0	if (variable == "REGISTER_FILE") {
220	0	return this->ReplaceValues->RegisterFile;
221	0	}
222	0	}
223
224	0	if (this->ReplaceValues->Target) {
225	0	if (variable == "TARGET_QUOTED") {
226	0	std::string targetQuoted = this->ReplaceValues->Target;
227	0	if (!targetQuoted.empty() && targetQuoted.front() != '\"') {
228	0	targetQuoted = cmStrCat('"', this->ReplaceValues->Target, '"');
229	0	}
230	0	return targetQuoted;
231	0	}
232	0	if (variable == "TARGET_UNQUOTED") {
233	0	std::string unquoted = this->ReplaceValues->Target;
234	0	std::string::size_type sz = unquoted.size();
235	0	if (sz > 2 && unquoted.front() == '\"' && unquoted.back() == '\"') {
236	0	unquoted = unquoted.substr(1, sz - 2);
237	0	}
238	0	return unquoted;
239	0	}
240	0	if (this->ReplaceValues->LanguageCompileFlags) {
241	0	if (variable == "LANGUAGE_COMPILE_FLAGS") {
242	0	return this->ReplaceValues->LanguageCompileFlags;
243	0	}
244	0	}
245	0	if (this->ReplaceValues->Target) {
246	0	if (variable == "TARGET") {
247	0	return this->ReplaceValues->Target;
248	0	}
249	0	}
250	0	if (variable == "TARGET_IMPLIB") {
251	0	return this->TargetImpLib;
252	0	}
253	0	if (variable == "TARGET_VERSION_MAJOR") {
254	0	if (this->ReplaceValues->TargetVersionMajor) {
255	0	return this->ReplaceValues->TargetVersionMajor;
256	0	}
257	0	return "0";
258	0	}
259	0	if (variable == "TARGET_VERSION_MINOR") {
260	0	if (this->ReplaceValues->TargetVersionMinor) {
261	0	return this->ReplaceValues->TargetVersionMinor;
262	0	}
263	0	return "0";
264	0	}
265	0	if (this->ReplaceValues->Target) {
266	0	if (variable == "TARGET_BASE") {
267		// Strip the last extension off the target name.
268	0	std::string targetBase = this->ReplaceValues->Target;
269	0	std::string::size_type pos = targetBase.rfind('.');
270	0	if (pos != std::string::npos) {
271	0	return targetBase.substr(0, pos);
272	0	}
273	0	return targetBase;
274	0	}
275	0	}
276	0	}
277	0	if (variable == "TARGET_SONAME" \|\| variable == "SONAME_FLAG" \|\|
278	0	variable == "TARGET_INSTALLNAME_DIR") {
279		// All these variables depend on TargetSOName
280	0	if (this->ReplaceValues->TargetSOName) {
281	0	if (variable == "TARGET_SONAME") {
282	0	return this->ReplaceValues->TargetSOName;
283	0	}
284	0	if (variable == "SONAME_FLAG" && this->ReplaceValues->SONameFlag) {
285	0	return this->ReplaceValues->SONameFlag;
286	0	}
287	0	if (this->ReplaceValues->TargetInstallNameDir &&
288	0	variable == "TARGET_INSTALLNAME_DIR") {
289	0	return this->ReplaceValues->TargetInstallNameDir;
290	0	}
291	0	}
292	0	return "";
293	0	}
294	0	if (this->ReplaceValues->LinkLibraries) {
295	0	if (variable == "LINK_LIBRARIES") {
296	0	return this->ReplaceValues->LinkLibraries;
297	0	}
298	0	}
299	0	if (this->ReplaceValues->Language) {
300	0	if (variable == "LANGUAGE") {
301	0	return this->ReplaceValues->Language;
302	0	}
303	0	}
304	0	if (this->ReplaceValues->CMTargetName) {
305	0	if (variable == "TARGET_NAME") {
306	0	return this->ReplaceValues->CMTargetName;
307	0	}
308	0	}
309	0	if (this->ReplaceValues->CMTargetType) {
310	0	if (variable == "TARGET_TYPE") {
311	0	return this->ReplaceValues->CMTargetType;
312	0	}
313	0	}
314	0	if (this->ReplaceValues->Output) {
315	0	if (variable == "OUTPUT") {
316	0	return this->ReplaceValues->Output;
317	0	}
318	0	}
319	0	if (this->ReplaceValues->FilePathWithOutput) {
320	0	if (variable == "OUTPUT_STORE_TO_FILE") {
321	0	return this->ReplaceValues->FilePathWithOutput;
322	0	}
323	0	}
324	0	if (variable == "CMAKE_COMMAND") {
325	0	return this->OutputConverter->ConvertToOutputFormat(
326	0	cmSystemTools::GetCMakeCommand(), cmOutputConverter::SHELL);
327	0	}
328	0	if (variable == "ROLE") {
329	0	if (this->ReplaceValues->Role) {
330	0	return this->ReplaceValues->Role;
331	0	}
332	0	return "";
333	0	}
334	0	if (variable == "CONFIG") {
335	0	if (this->ReplaceValues->Config) {
336	0	return this->ReplaceValues->Config;
337	0	}
338	0	return "";
339	0	}
340
341	0	auto compIt = this->Compilers.find(variable);
342
343	0	if (compIt != this->Compilers.end()) {
344	0	std::string const& compilerPath =
345	0	this->VariableMappings[cmStrCat("CMAKE_", compIt->second, "_COMPILER")];
346	0	std::string ret = this->ConvertToOutputForExisting(compilerPath);
347	0	std::string const& compilerArg1 = this->VariableMappings[cmStrCat(
348	0	"CMAKE_", compIt->second, "_COMPILER_ARG1")];
349	0	std::string const& compilerTarget = this->VariableMappings[cmStrCat(
350	0	"CMAKE_", compIt->second, "_COMPILER_TARGET")];
351	0	std::string const& compilerOptionTarget = this->VariableMappings[cmStrCat(
352	0	"CMAKE_", compIt->second, "_COMPILE_OPTIONS_TARGET")];
353	0	std::string const& compilerExternalToolchain =
354	0	this->VariableMappings[cmStrCat("CMAKE_", compIt->second,
355	0	"_COMPILER_EXTERNAL_TOOLCHAIN")];
356	0	std::string const& compilerOptionExternalToolchain =
357	0	this->VariableMappings[cmStrCat("CMAKE_", compIt->second,
358	0	"_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN")];
359	0	std::string const& compilerOptionSysroot = this->VariableMappings[cmStrCat(
360	0	"CMAKE_", compIt->second, "_COMPILE_OPTIONS_SYSROOT")];
361
362	0	if (compIt->second == this->ReplaceValues->Language &&
363	0	this->ReplaceValues->Launcher) {
364		// Add launcher as part of expansion so that it always appears
365		// immediately before the command itself, regardless of whether the
366		// overall rule template contains other content at the front.
367	0	ret = cmStrCat(this->ReplaceValues->Launcher, ' ', std::move(ret));
368	0	}
369
370		// if there are required arguments to the compiler add it
371		// to the compiler string
372	0	if (!compilerArg1.empty()) {
373	0	ret = cmStrCat(std::move(ret), ' ', compilerArg1);
374	0	}
375	0	if (!compilerTarget.empty() && !compilerOptionTarget.empty()) {
376	0	ret =
377	0	cmStrCat(std::move(ret), ' ', compilerOptionTarget, compilerTarget);
378	0	}
379	0	if (!compilerExternalToolchain.empty() &&
380	0	!compilerOptionExternalToolchain.empty()) {
381	0	ret = cmStrCat(std::move(ret), ' ', compilerOptionExternalToolchain,
382	0	this->OutputConverter->EscapeForShell(
383	0	compilerExternalToolchain, true));
384	0	}
385	0	std::string sysroot;
386		// Some platforms may use separate sysroots for compiling and linking.
387		// When the build step is link, pass the link sysroot instead.
388	0	if (this->BuildStep == cmBuildStep::Link) {
389	0	sysroot = this->LinkerSysroot;
390	0	} else {
391	0	sysroot = this->CompilerSysroot;
392	0	}
393	0	if (!sysroot.empty() && !compilerOptionSysroot.empty()) {
394	0	ret = cmStrCat(std::move(ret), ' ', compilerOptionSysroot,
395	0	this->OutputConverter->EscapeForShell(sysroot, true));
396	0	}
397	0	return ret;
398	0	}
399
400	0	auto mapIt = this->VariableMappings.find(variable);
401	0	if (mapIt != this->VariableMappings.end()) {
402	0	if (variable.find("_FLAG") == std::string::npos) {
403	0	return this->ConvertToOutputForExisting(mapIt->second);
404	0	}
405	0	return mapIt->second;
406	0	}
407	0	return variable;
408	0	}
409
410		void cmRulePlaceholderExpander::ExpandRuleVariables(
411		cmOutputConverter* outputConverter, std::string& s,
412		RuleVariables const& replaceValues)
413	0	{
414	0	this->OutputConverter = outputConverter;
415	0	this->ReplaceValues = &replaceValues;
416
417	0	this->ExpandVariables(s);
418	0	}