Commit 7891f69c authored by Brad King's avatar Brad King Committed by Kitware Robot

Merge topic 'autogen_cmStrCat'

ca292311 Autogen: Modernize to use cmStrCat for string concatenation
d02a99d9 Autogen: Modernize code to use cm::string_view for the info writer
Acked-by: Kitware Robot's avatarKitware Robot <kwrobot@kitware.com>
Merge-request: !3663
parents 6f3c429e ca292311
......@@ -353,9 +353,8 @@ bool cmQtAutoGen::RccLister::list(std::string const& qrcFile,
// Log command
if (verbose) {
std::string msg = "Running command:\n";
msg += QuotedCommand(cmd);
msg += '\n';
std::string msg =
cmStrCat("Running command:\n", QuotedCommand(cmd), '\n');
cmSystemTools::Stdout(msg);
}
......
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmQtAutoGenGlobalInitializer.h"
#include "cmQtAutoGen.h"
#include "cmQtAutoGenInitializer.h"
#include "cmCustomCommandLines.h"
#include "cmDuration.h"
......@@ -11,15 +9,18 @@
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmProcessOutput.h"
#include "cmQtAutoGen.h"
#include "cmQtAutoGenInitializer.h"
#include "cmState.h"
#include "cmStateTypes.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
#include "cmTarget.h"
#include <utility>
#include "cm_memory.hxx"
#include <utility>
cmQtAutoGenGlobalInitializer::Keywords::Keywords()
: AUTOMOC("AUTOMOC")
, AUTOUIC("AUTOUIC")
......@@ -119,23 +120,17 @@ cmQtAutoGenGlobalInitializer::cmQtAutoGenGlobalInitializer(
bool const uicDisabled = (uic && !uicAvailable);
bool const rccDisabled = (rcc && !rccAvailable);
if (mocDisabled || uicDisabled || rccDisabled) {
std::string msg = "AUTOGEN: No valid Qt version found for target ";
msg += target->GetName();
msg += ". ";
msg += cmQtAutoGen::Tools(mocDisabled, uicDisabled, rccDisabled);
msg += " disabled. Consider adding:\n";
{
std::string version = (qtVersion.second == 0)
? std::string("<QTVERSION>")
: std::to_string(qtVersion.second);
std::string comp = uicDisabled ? "Widgets" : "Core";
msg += " find_package(Qt";
msg += version;
msg += " COMPONENTS ";
msg += comp;
msg += ")\n";
}
msg += "to your CMakeLists.txt file.";
cmAlphaNum version = (qtVersion.second == 0)
? cmAlphaNum("<QTVERSION>")
: cmAlphaNum(qtVersion.second);
cmAlphaNum component = uicDisabled ? "Widgets" : "Core";
std::string const msg = cmStrCat(
"AUTOGEN: No valid Qt version found for target ",
target->GetName(), ". ",
cmQtAutoGen::Tools(mocDisabled, uicDisabled, rccDisabled),
" disabled. Consider adding:\n", " find_package(Qt", version,
" COMPONENTS ", component, ")\n", "to your CMakeLists.txt file.");
target->Makefile->IssueMessage(MessageType::AUTHOR_WARNING, msg);
}
if (mocIsValid || uicIsValid || rccIsValid) {
......
......@@ -156,30 +156,27 @@ std::string cmQtAutoGenInitializer::InfoWriter::ListJoin(IT it_begin,
return res;
}
std::string cmQtAutoGenInitializer::InfoWriter::ConfigKey(
const char* key, std::string const& config)
inline std::string cmQtAutoGenInitializer::InfoWriter::ConfigKey(
cm::string_view key, std::string const& config)
{
std::string ckey = key;
ckey += '_';
ckey += config;
return ckey;
return cmStrCat(key, "_", config);
}
void cmQtAutoGenInitializer::InfoWriter::Write(const char* key,
void cmQtAutoGenInitializer::InfoWriter::Write(cm::string_view key,
std::string const& value)
{
Ofs_ << "set(" << key << " " << cmOutputConverter::EscapeForCMake(value)
<< ")\n";
};
void cmQtAutoGenInitializer::InfoWriter::WriteUInt(const char* key,
void cmQtAutoGenInitializer::InfoWriter::WriteUInt(cm::string_view key,
unsigned int value)
{
Ofs_ << "set(" << key << " " << value << ")\n";
};
template <class C>
void cmQtAutoGenInitializer::InfoWriter::WriteStrings(const char* key,
void cmQtAutoGenInitializer::InfoWriter::WriteStrings(cm::string_view key,
C const& container)
{
Ofs_ << "set(" << key << " \""
......@@ -187,31 +184,29 @@ void cmQtAutoGenInitializer::InfoWriter::WriteStrings(const char* key,
}
void cmQtAutoGenInitializer::InfoWriter::WriteConfig(
const char* key, std::map<std::string, std::string> const& map)
cm::string_view key, std::map<std::string, std::string> const& map)
{
for (auto const& item : map) {
Write(ConfigKey(key, item.first).c_str(), item.second);
Write(ConfigKey(key, item.first), item.second);
}
};
template <class C>
void cmQtAutoGenInitializer::InfoWriter::WriteConfigStrings(
const char* key, std::map<std::string, C> const& map)
cm::string_view key, std::map<std::string, C> const& map)
{
for (auto const& item : map) {
WriteStrings(ConfigKey(key, item.first).c_str(), item.second);
WriteStrings(ConfigKey(key, item.first), item.second);
}
}
void cmQtAutoGenInitializer::InfoWriter::WriteNestedLists(
const char* key, std::vector<std::vector<std::string>> const& lists)
cm::string_view key, std::vector<std::vector<std::string>> const& lists)
{
std::vector<std::string> seplist;
for (const std::vector<std::string>& list : lists) {
std::string blist = "{";
blist += ListJoin(list.begin(), list.end());
blist += "}";
seplist.push_back(std::move(blist));
seplist.reserve(lists.size());
for (std::vector<std::string> const& list : lists) {
seplist.push_back(cmStrCat("{", ListJoin(list.begin(), list.end()), "}"));
}
Write(key, cmJoin(seplist, cmQtAutoGen::ListSep));
};
......@@ -721,14 +716,13 @@ bool cmQtAutoGenInitializer::InitScanFiles()
if (muf.MocIt || muf.UicIt) {
// Search for the default header file and a private header
std::string const& srcPath = muf.SF->GetFullPath();
std::string basePath = cmQtAutoGen::SubDirPrefix(srcPath);
basePath += cmSystemTools::GetFilenameWithoutLastExtension(srcPath);
std::string basePath =
cmStrCat(cmQtAutoGen::SubDirPrefix(srcPath),
cmSystemTools::GetFilenameWithoutLastExtension(srcPath));
for (auto const& suffix : suffixes) {
std::string const suffixedPath = basePath + suffix;
for (auto const& ext : exts) {
std::string fullPath = suffixedPath;
fullPath += '.';
fullPath += ext;
std::string fullPath = cmStrCat(suffixedPath, '.', ext);
auto constexpr locationKind = cmSourceFileLocationKind::Known;
cmSourceFile* sf = makefile->GetSource(fullPath, locationKind);
......@@ -833,9 +827,8 @@ bool cmQtAutoGenInitializer::InitScanFiles()
this->AutogenTarget.DependFiles.insert(muf->RealPath);
}
} else if (this->CMP0071Warn) {
std::string msg;
msg += cmPolicies::GetPolicyWarning(cmPolicies::CMP0071);
msg += '\n';
std::string msg =
cmStrCat(cmPolicies::GetPolicyWarning(cmPolicies::CMP0071), '\n');
std::string property;
if (this->Moc.Enabled && this->Uic.Enabled) {
property = kw.SKIP_AUTOGEN;
......@@ -888,18 +881,10 @@ bool cmQtAutoGenInitializer::InitScanFiles()
for (Qrc& qrc : this->Rcc.Qrcs) {
qrc.PathChecksum = fpathCheckSum.getPart(qrc.QrcFile);
// RCC output file name
qrc.RccFile = cmStrCat(this->Dir.Build + "/", qrc.PathChecksum,
"/qrc_", qrc.QrcName, ".cpp");
{
std::string rccFile = this->Dir.Build + "/";
rccFile += qrc.PathChecksum;
rccFile += "/qrc_";
rccFile += qrc.QrcName;
rccFile += ".cpp";
qrc.RccFile = std::move(rccFile);
}
{
std::string base = this->Dir.Info;
base += "/RCC";
base += qrc.QrcName;
std::string base = cmStrCat(this->Dir.Info, "/RCC", qrc.QrcName);
if (!qrc.Unique) {
base += qrc.PathChecksum;
}
......@@ -932,8 +917,7 @@ bool cmQtAutoGenInitializer::InitScanFiles()
// Replace '-' with '_'. The former is not valid for symbol names.
std::replace(name.begin(), name.end(), '-', '_');
if (!qrc.Unique) {
name += "_";
name += qrc.PathChecksum;
name += cmStrCat("_", qrc.PathChecksum);
}
std::vector<std::string> nameOpts;
nameOpts.emplace_back("-name");
......@@ -1157,8 +1141,8 @@ bool cmQtAutoGenInitializer::InitRccTargets()
currentLine.push_back("$<CONFIG>");
commandLines.push_back(std::move(currentLine));
}
std::string ccComment = "Automatic RCC for ";
ccComment += FileProjectRelativePath(makefile, qrc.QrcFile);
std::string ccComment = cmStrCat(
"Automatic RCC for ", FileProjectRelativePath(makefile, qrc.QrcFile));
if (qrc.Generated || this->Rcc.GlobalTarget) {
// Create custom rcc target
......@@ -1226,9 +1210,8 @@ bool cmQtAutoGenInitializer::SetupCustomTargets()
{
// Create info directory on demand
if (!cmSystemTools::MakeDirectory(this->Dir.Info)) {
std::string emsg = ("AutoGen: Could not create directory: ");
emsg += Quoted(this->Dir.Info);
cmSystemTools::Error(emsg);
cmSystemTools::Error(cmStrCat("AutoGen: Could not create directory: ",
Quoted(this->Dir.Info)));
return false;
}
......@@ -1311,10 +1294,8 @@ bool cmQtAutoGenInitializer::SetupWriteAutogenInfo()
}
if (muf->MocIt || muf->UicIt) {
headers.emplace_back(muf->RealPath);
std::string flags;
flags += muf->MocIt ? 'M' : 'm';
flags += muf->UicIt ? 'U' : 'u';
headersFlags.emplace_back(std::move(flags));
headersFlags.emplace_back(
cmStrCat(muf->MocIt ? "M" : "m", muf->UicIt ? "U" : "u"));
}
}
}
......@@ -1323,14 +1304,13 @@ bool cmQtAutoGenInitializer::SetupWriteAutogenInfo()
cmFilePathChecksum const fpathCheckSum(makefile);
std::unordered_set<std::string> emitted;
for (std::string const& hdr : headers) {
std::string basePath = fpathCheckSum.getPart(hdr);
basePath += "/moc_";
basePath += cmSystemTools::GetFilenameWithoutLastExtension(hdr);
for (unsigned int ii = 1; ii != 1024; ++ii) {
std::string basePath =
cmStrCat(fpathCheckSum.getPart(hdr), "/moc_",
cmSystemTools::GetFilenameWithoutLastExtension(hdr));
for (int ii = 1; ii != 1024; ++ii) {
std::string path = basePath;
if (ii > 1) {
path += '_';
path += std::to_string(ii);
path += cmStrCat("_", ii);
}
path += ".cpp";
if (emitted.emplace(path).second) {
......@@ -1369,10 +1349,8 @@ bool cmQtAutoGenInitializer::SetupWriteAutogenInfo()
}
if (muf->MocIt || muf->UicIt) {
sources.emplace_back(muf->RealPath);
std::string flags;
flags += muf->MocIt ? 'M' : 'm';
flags += muf->UicIt ? 'U' : 'u';
sourcesFlags.emplace_back(std::move(flags));
sourcesFlags.emplace_back(
cmStrCat(muf->MocIt ? "M" : "m", muf->UicIt ? "U" : "u"));
}
}
}
......@@ -1426,9 +1404,8 @@ bool cmQtAutoGenInitializer::SetupWriteAutogenInfo()
ofs.WriteStrings("AM_UIC_SEARCH_PATHS", this->Uic.SearchPaths);
}
} else {
std::string err = "AutoGen: Could not write file ";
err += this->AutogenTarget.InfoFile;
cmSystemTools::Error(err);
cmSystemTools::Error(cmStrCat("AutoGen: Could not write file ",
this->AutogenTarget.InfoFile));
return false;
}
......@@ -1467,9 +1444,8 @@ bool cmQtAutoGenInitializer::SetupWriteRccInfo()
ofs.WriteStrings("ARCC_OPTIONS", qrc.Options);
ofs.WriteStrings("ARCC_INPUTS", qrc.Resources);
} else {
std::string err = "AutoRcc: Could not write file ";
err += qrc.InfoFile;
cmSystemTools::Error(err);
cmSystemTools::Error(
cmStrCat("AutoRcc: Could not write file ", qrc.InfoFile));
return false;
}
}
......@@ -1524,13 +1500,10 @@ bool cmQtAutoGenInitializer::AddToSourceGroup(std::string const& fileName,
if (!groupName.empty()) {
sourceGroup = makefile->GetOrCreateSourceGroup(groupName);
if (sourceGroup == nullptr) {
std::string err;
err += genNameUpper;
err += " error in ";
err += property;
err += ": Could not find or create the source group ";
err += cmQtAutoGen::Quoted(groupName);
cmSystemTools::Error(err);
cmSystemTools::Error(
cmStrCat(genNameUpper, " error in ", property,
": Could not find or create the source group ",
cmQtAutoGen::Quoted(groupName)));
return false;
}
}
......@@ -1622,12 +1595,8 @@ bool cmQtAutoGenInitializer::GetQtExecutable(GenVarsT& genVars,
bool ignoreMissingTarget) const
{
auto print_err = [this, &genVars](std::string const& err) {
std::string msg = genVars.GenNameUpper;
msg += " for target ";
msg += this->Target->GetName();
msg += ": ";
msg += err;
cmSystemTools::Error(msg);
cmSystemTools::Error(cmStrCat(genVars.GenNameUpper, " for target ",
this->Target->GetName(), ": ", err));
};
// Custom executable
......@@ -1687,11 +1656,8 @@ bool cmQtAutoGenInitializer::GetQtExecutable(GenVarsT& genVars,
std::make_shared<cmQtAutoGen::CompilerFeatures>();
return true;
}
std::string err = "Could not find ";
err += executable;
err += " executable target ";
err += targetName;
print_err(err);
print_err(cmStrCat("Could not find ", executable, " executable target ",
targetName));
return false;
}
}
......
......@@ -6,6 +6,7 @@
#include "cmConfigure.h" // IWYU pragma: keep
#include "cmGeneratedFileStream.h"
#include "cmQtAutoGen.h"
#include "cm_string_view.hxx"
#include <map>
#include <memory>
......@@ -85,24 +86,24 @@ public:
/// @return True if the file is open
explicit operator bool() const { return static_cast<bool>(Ofs_); }
void Write(const char* text) { Ofs_ << text; }
void Write(const char* key, std::string const& value);
void WriteUInt(const char* key, unsigned int value);
void Write(cm::string_view text) { Ofs_ << text; }
void Write(cm::string_view, std::string const& value);
void WriteUInt(cm::string_view, unsigned int value);
template <class C>
void WriteStrings(const char* key, C const& container);
void WriteConfig(const char* key,
void WriteStrings(cm::string_view, C const& container);
void WriteConfig(cm::string_view,
std::map<std::string, std::string> const& map);
template <class C>
void WriteConfigStrings(const char* key,
void WriteConfigStrings(cm::string_view,
std::map<std::string, C> const& map);
void WriteNestedLists(const char* key,
void WriteNestedLists(cm::string_view,
std::vector<std::vector<std::string>> const& lists);
private:
template <class IT>
static std::string ListJoin(IT it_begin, IT it_end);
static std::string ConfigKey(const char* key, std::string const& config);
static std::string ConfigKey(cm::string_view, std::string const& config);
private:
cmGeneratedFileStream Ofs_;
......
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmQtAutoGenerator.h"
#include "cmQtAutoGen.h"
#include "cmsys/FStream.hxx"
#include "cm_memory.hxx"
#include "cmsys/FStream.hxx"
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmQtAutoGen.h"
#include "cmState.h"
#include "cmStateDirectory.h"
#include "cmStateSnapshot.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
#include "cmake.h"
......@@ -60,19 +60,13 @@ void cmQtAutoGenerator::Logger::SetColorOutput(bool value)
std::string cmQtAutoGenerator::Logger::HeadLine(std::string const& title)
{
std::string head = title;
head += '\n';
head.append(head.size() - 1, '-');
head += '\n';
return head;
return cmStrCat(title, "\n", std::string(title.size(), '-'), "\n");
}
void cmQtAutoGenerator::Logger::Info(GenT genType,
std::string const& message) const
{
std::string msg = GeneratorName(genType);
msg += ": ";
msg += message;
std::string msg = cmStrCat(GeneratorName(genType), ": ", message);
if (msg.back() != '\n') {
msg.push_back('\n');
}
......@@ -110,19 +104,13 @@ void cmQtAutoGenerator::Logger::WarningFile(GenT genType,
std::string const& filename,
std::string const& message) const
{
std::string msg = " ";
msg += Quoted(filename);
msg.push_back('\n');
// Message
msg += message;
Warning(genType, msg);
Warning(genType, cmStrCat(" ", Quoted(filename), "\n", message));
}
void cmQtAutoGenerator::Logger::Error(GenT genType,
std::string const& message) const
{
std::string msg;
msg += HeadLine(GeneratorName(genType) + " error");
std::string msg = HeadLine(GeneratorName(genType) + " error");
// Message
msg += message;
if (msg.back() != '\n') {
......@@ -139,12 +127,7 @@ void cmQtAutoGenerator::Logger::ErrorFile(GenT genType,
std::string const& filename,
std::string const& message) const
{
std::string emsg = " ";
emsg += Quoted(filename);
emsg += '\n';
// Message
emsg += message;
Error(genType, emsg);
Error(genType, cmStrCat(" ", Quoted(filename), '\n', message));
}
void cmQtAutoGenerator::Logger::ErrorCommand(
......@@ -280,10 +263,8 @@ bool cmQtAutoGenerator::Run(std::string const& infoFile,
InfoFile_ = infoFile;
cmSystemTools::ConvertToUnixSlashes(InfoFile_);
if (!InfoFileTime_.Load(InfoFile_)) {
std::string msg = "AutoGen: The info file ";
msg += Quoted(InfoFile_);
msg += " is not readable\n";
cmSystemTools::Stderr(msg);
cmSystemTools::Stderr(cmStrCat("AutoGen: The info file ",
Quoted(InfoFile_), " is not readable\n"));
return false;
}
InfoDir_ = cmSystemTools::GetFilenamePath(infoFile);
......
......@@ -302,10 +302,9 @@ void cmQtAutoMocUic::JobMocPredefsT::Process()
}
// Execute command
if (!RunProcess(GenT::MOC, result, cmd, reason.get())) {
std::string msg = "The content generation command for ";
msg += Quoted(predefsFileRel);
msg += " failed.\n";
msg += result.ErrorMessage;
std::string msg =
cmStrCat("The content generation command for ",
Quoted(predefsFileRel), " failed.\n", result.ErrorMessage);
LogCommandError(GenT::MOC, msg, cmd, result.StdOut);
return;
}
......@@ -314,9 +313,8 @@ void cmQtAutoMocUic::JobMocPredefsT::Process()
// (Re)write predefs file only on demand
if (cmQtAutoGenerator::FileDiffers(predefsFileAbs, result.StdOut)) {
if (!cmQtAutoGenerator::FileWrite(predefsFileAbs, result.StdOut)) {
std::string msg = "Writing ";
msg += Quoted(predefsFileRel);
msg += " failed.";
std::string msg =
cmStrCat("Writing ", Quoted(predefsFileRel), " failed.");
LogFileError(GenT::MOC, predefsFileAbs, msg);
return;
}
......@@ -326,9 +324,8 @@ void cmQtAutoMocUic::JobMocPredefsT::Process()
Log().Info(GenT::MOC, "Touching " + Quoted(predefsFileRel));
}
if (!cmSystemTools::Touch(predefsFileAbs, false)) {
std::string msg = "Touching ";
msg += Quoted(predefsFileAbs);
msg += " failed.";
std::string msg =
cmStrCat("Touching ", Quoted(predefsFileAbs), " failed.");
LogFileError(GenT::MOC, predefsFileAbs, msg);
return;
}
......@@ -663,13 +660,11 @@ bool cmQtAutoMocUic::JobEvaluateT::MocEvalSource(
if (!sourceIncludesDotMoc && !parseData.Macro.empty() &&
!(relaxedMode && sourceIncludesMocUnderscore)) {
{
std::string emsg = "The file contains a ";
emsg += Quoted(parseData.Macro);
emsg += " macro, but does not include ";
emsg += Quoted(sourceBase + ".moc");
emsg += "!\nConsider to\n - add #include \"";
emsg += sourceBase;
emsg += ".moc\"\n - enable SKIP_AUTOMOC for this file";
std::string emsg =
cmStrCat("The file contains a ", Quoted(parseData.Macro),
" macro, but does not include ", Quoted(sourceBase + ".moc"),
"!\nConsider to\n - add #include \"", sourceBase,
".moc\"\n - enable SKIP_AUTOMOC for this file");
LogFileError(GenT::MOC, sourceFile.FileName, emsg);
}
return false;
......@@ -700,18 +695,14 @@ bool cmQtAutoMocUic::JobEvaluateT::MocEvalSource(
// used. This is for KDE4 compatibility.
{
// Issue a warning
std::string msg = "The file contains a ";
msg += Quoted(parseData.Macro);
msg += " macro, but does not include ";
msg += Quoted(sourceBase + ".moc");
msg += ".\nInstead it includes ";
msg += Quoted(incKey.Key);
msg += ".\nRunning moc on the source\n ";
msg += Quoted(sourceFile.FileName);
msg += "!\nBetter include ";
msg += Quoted(sourceBase + ".moc");
msg += " for compatibility with regular mode.\n";
msg += "This is a CMAKE_AUTOMOC_RELAXED_MODE warning.\n";
std::string msg = cmStrCat(
"The file contains a ", Quoted(parseData.Macro),
" macro, but does not include ", Quoted(sourceBase + ".moc"),
".\nInstead it includes ", Quoted(incKey.Key),
".\nRunning moc on the source\n ", Quoted(sourceFile.FileName),
"!\nBetter include ", Quoted(sourceBase + ".moc"),
" for compatibility with regular mode.\n",
"This is a CMAKE_AUTOMOC_RELAXED_MODE warning.\n");
Log().WarningFile(GenT::MOC, sourceFile.FileName, msg);
}
// Create mapping
......@@ -764,28 +755,22 @@ bool cmQtAutoMocUic::JobEvaluateT::MocEvalSource(
}
// Issue a warning
if (ownMoc && parseData.Macro.empty()) {
std::string msg = "The file includes the moc file ";
msg += Quoted(incKey.Key);
msg += ", but does not contain a\n";
msg += MocConst().MacrosString();
msg += " macro.\nRunning moc on the header\n ";
msg += Quoted(header->FileName);
msg += "!\nBetter include ";
msg += Quoted("moc_" + incKey.Base + ".cpp");
msg += " for a compatibility with regular mode.\n";
msg += "This is a CMAKE_AUTOMOC_RELAXED_MODE warning.\n";
std::string msg = cmStrCat(
"The file includes the moc file ", Quoted(incKey.Key),
", but does not contain a\n", MocConst().MacrosString(),
" macro.\nRunning moc on the header\n ", Quoted(header->FileName),
"!\nBetter include ", Quoted("moc_" + incKey.Base + ".cpp"),
" for a compatibility with regular mode.\n",
"This is a CMAKE_AUTOMOC_RELAXED_MODE warning.\n");
Log().WarningFile(GenT::MOC, sourceFile.FileName, msg);
} else {
std::string msg = "The file includes the moc file ";
msg += Quoted(incKey.Key);
msg += " instead of ";
msg += Quoted("moc_" + incKey.Base + ".cpp");
msg += ".\nRunning moc on the header\n ";
msg += Quoted(header->FileName);
msg += "!\nBetter include ";
msg += Quoted("moc_" + incKey.Base + ".cpp");
msg += " for compatibility with regular mode.\n";
msg += "This is a CMAKE_AUTOMOC_RELAXED_MODE warning.\n";
std::string msg = cmStrCat(