reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2025-02-26 06:55:34 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Autogen: Modernize to use cmStrCat for string concatenation

Browse Source
This commit is contained in:
Sebastian Holtermann 2019-08-06 10:40:49 +02:00
parent d02a99d9d3
commit ca2923110c
6 changed files with 151 additions and 258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Source/cmQtAutoGen.cxx
View File

@ -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);
}

37
Source/cmQtAutoGenGlobalInitializer.cxx
View File

@ -1,8 +1,6 @@
/* 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) {

99
Source/cmQtAutoGenInitializer.cxx
View File

@ -716,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);
@ -828,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;
@ -883,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;
}
@ -927,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");
@ -1152,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
@ -1221,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;
}
@ -1306,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"));
}
}
}
@ -1318,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) {
@ -1364,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"));
}
}
}
@ -1421,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;
}
@ -1462,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;
}
}
@ -1519,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;
}
}
@ -1617,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
@ -1682,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;
}
}

39
Source/cmQtAutoGenerator.cxx
View File

@ -1,17 +1,17 @@
/* 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);

186
Source/cmQtAutoMocUic.cxx
View File

@ -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(
"The file includes the moc file ", Quoted(incKey.Key),
" instead of ", Quoted("moc_" + incKey.Base + ".cpp"),
".\nRunning moc on the header\n ", Quoted(header->FileName),
"!\nBetter include ", Quoted("moc_" + incKey.Base + ".cpp"),
" for compatibility with regular mode.\n",
"This is a CMAKE_AUTOMOC_RELAXED_MODE warning.\n");
Log().WarningFile(GenT::MOC, sourceFile.FileName, msg);
}
// Create mapping
@ -811,11 +796,9 @@ bool cmQtAutoMocUic::JobEvaluateT::MocEvalSource(
}
// Accept but issue a warning if moc isn't required
if (parseData.Macro.empty()) {
std::string msg = "The file includes the moc file ";
msg += Quoted(incKey.Key);
msg += ", but does not contain a ";
msg += MocConst().MacrosString();
msg += " macro.";
std::string msg = cmStrCat(
"The file includes the moc file ", Quoted(incKey.Key),
", but does not contain a ", MocConst().MacrosString(), " macro.");
Log().WarningFile(GenT::MOC, sourceFile.FileName, msg);
}
// Create mapping
@ -841,9 +824,7 @@ cmQtAutoMocUic::JobEvaluateT::MocFindIncludedHeader(
}
// Search in include directories
for (std::string const& path : MocConst().IncludePaths) {
std::string testPath = path;
testPath += '/';
testPath += includeBase;
std::string testPath = cmStrCat(path, '/', includeBase);
SourceFileHandleT res = MocFindHeader(testPath);
if (res) {
return res;
@ -893,10 +874,9 @@ std::string cmQtAutoMocUic::JobEvaluateT::MocMessageTestHeaders(
{
std::ostringstream res;
{
std::string exts = ".{";
exts += cmJoin(BaseConst().HeaderExtensions, ",");
exts += '}';
// Compose result string
std::string exts =
cmStrCat(".{", cmJoin(BaseConst().HeaderExtensions, ","),
'}'); // Compose result string
res << " " << fileBase << exts << '\n';
for (std::string const& path : MocConst().IncludePaths) {
res << " " << path << '/' << fileBase << exts << '\n';
@ -914,9 +894,8 @@ bool cmQtAutoMocUic::JobEvaluateT::MocRegisterIncluded(
if (handle) {
// Check if the output file would be generated from different source files
if (handle->SourceFile != sourceFileHandle) {
std::string msg = "The source files\n ";
msg += Quoted(includerFileHandle->FileName);
msg += '\n';
std::string msg = cmStrCat("The source files\n ",
Quoted(includerFileHandle->FileName), '\n');
for (auto const& item : handle->IncluderFiles) {
msg += " ";
msg += Quoted(item->FileName);
@ -1020,9 +999,8 @@ bool cmQtAutoMocUic::JobEvaluateT::UicRegisterMapping(
MappingHandleT const& handle = it->second;
if (handle->SourceFile != uiFileHandle) {
// The output file already gets generated - from a different .ui file!
std::string msg = "The source files\n ";
msg += Quoted(includerFileHandle->FileName);
msg += '\n';
std::string msg = cmStrCat("The source files\n ",
Quoted(includerFileHandle->FileName), '\n');
for (auto const& item : handle->IncluderFiles) {
msg += " ";
msg += Quoted(item->FileName);
@ -1063,8 +1041,7 @@ cmQtAutoMocUic::JobEvaluateT::UicFindIncludedUi(
std::string const& sourceFile, std::string const& sourceDir,
IncludeKeyT const& incKey) const
{
std::string searchFileName = incKey.Base;
searchFileName += ".ui";
std::string searchFileName = cmStrCat(incKey.Base, ".ui");
// Collect search paths list
std::vector<std::string> testFiles;
{
@ -1074,26 +1051,17 @@ cmQtAutoMocUic::JobEvaluateT::UicFindIncludedUi(
// Vicinity of the source
testFiles.emplace_back(sourceDir + searchFileName);
if (!incKey.Dir.empty()) {
std::string path = sourceDir;
path += incKey.Dir;
path += searchFileName;
testFiles.emplace_back(path);
testFiles.emplace_back(cmStrCat(sourceDir, incKey.Dir, searchFileName));
}
// AUTOUIC search paths
if (!searchPaths.empty()) {
for (std::string const& sPath : searchPaths) {
std::string path = sPath;
path += '/';
path += searchFileName;
testFiles.emplace_back(std::move(path));
testFiles.emplace_back(cmStrCat(sPath, '/', searchFileName));
}
if (!incKey.Dir.empty()) {
for (std::string const& sPath : searchPaths) {
std::string path = sPath;
path += '/';
path += incKey.Dir;
path += searchFileName;
testFiles.emplace_back(std::move(path));
testFiles.emplace_back(
cmStrCat(sPath, '/', incKey.Dir, searchFileName));
}
}
}
@ -1118,11 +1086,10 @@ cmQtAutoMocUic::JobEvaluateT::UicFindIncludedUi(
// Log error
{
std::string msg = "The file includes the uic file ";
msg += Quoted(incKey.Key);
msg += ",\nbut the user interface file ";
msg += Quoted(searchFileName);
msg += "\ncould not be found in the following locations\n";
std::string msg =
cmStrCat("The file includes the uic file ", Quoted(incKey.Key),
",\nbut the user interface file ", Quoted(searchFileName),
"\ncould not be found in the following locations\n");
for (std::string const& testFile : testFiles) {
msg += " ";
msg += Quoted(testFile);
@ -1418,10 +1385,9 @@ void cmQtAutoMocUic::JobMocT::Process()
}
} else {
// Moc command failed
std::string msg = "The moc process failed to compile\n ";
msg += Quoted(sourceFile);
msg += "\ninto\n ";
msg += Quoted(outputFile);
std::string msg =
cmStrCat("The moc process failed to compile\n ", Quoted(sourceFile),
"\ninto\n ", Quoted(outputFile));
if (Mapping->IncluderFiles.empty()) {
msg += ".\n";
} else {
@ -1467,11 +1433,9 @@ void cmQtAutoMocUic::JobUicT::Process()
}
} else {
// Uic command failed
std::string msg = "The uic process failed to compile\n ";
msg += Quoted(sourceFile);
msg += "\ninto\n ";
msg += Quoted(outputFile);
msg += "\nincluded by\n";
std::string msg =
cmStrCat("The uic process failed to compile\n ", Quoted(sourceFile),
"\ninto\n ", Quoted(outputFile), "\nincluded by\n");
for (auto const& item : Mapping->IncluderFiles) {
msg += " ";
msg += Quoted(item->FileName);
@ -1564,12 +1528,8 @@ bool cmQtAutoMocUic::Init(cmMakefile* makefile)
if (length >= 2) {
std::string::const_iterator itBeg = value.begin() + (pos + 1);
std::string::const_iterator itEnd = itBeg + (length - 2);
{
std::string subValue(itBeg, itEnd);
std::vector<std::string> list;
cmSystemTools::ExpandListArgument(subValue, list);
lists.push_back(std::move(list));
}
lists.emplace_back(
cmSystemTools::ExpandedListArgument(std::string(itBeg, itEnd)));
}
pos += length;
pos += ListSep.size();
@ -1580,9 +1540,7 @@ bool cmQtAutoMocUic::Init(cmMakefile* makefile)
auto InfoGetConfig = [makefile, this](const char* key) -> std::string {
const char* valueConf = nullptr;
{
std::string keyConf = key;
keyConf += '_';
keyConf += InfoConfig();
std::string keyConf = cmStrCat(key, '_', InfoConfig());
valueConf = makefile->GetDefinition(keyConf);
}
if (valueConf == nullptr) {
@ -1653,9 +1611,9 @@ bool cmQtAutoMocUic::Init(cmMakefile* makefile)
return LogInfoError("CMake executable file name missing.");
}
if (!BaseConst_.CMakeExecutableTime.Load(BaseConst_.CMakeExecutable)) {
std::string error = "The CMake executable ";
error += Quoted(BaseConst_.CMakeExecutable);
error += " does not exist.";
std::string error =
cmStrCat("The CMake executable ", Quoted(BaseConst_.CMakeExecutable),
" does not exist.");
return LogInfoError(error);
}
BaseConst_.ParseCacheFile = InfoGetConfig("AM_PARSE_CACHE_FILE");
@ -1684,9 +1642,9 @@ bool cmQtAutoMocUic::Init(cmMakefile* makefile)
MocConst_.Enabled = true;
// Load the executable file time
if (!MocConst_.ExecutableTime.Load(MocConst_.Executable)) {
std::string error = "The moc executable ";
error += Quoted(MocConst_.Executable);
error += " does not exist.";
std::string error =
cmStrCat("The moc executable ", Quoted(MocConst_.Executable),
" does not exist.");
return LogInfoError(error);
}
for (std::string& sfl : InfoGetList("AM_MOC_SKIP")) {
@ -1752,9 +1710,9 @@ bool cmQtAutoMocUic::Init(cmMakefile* makefile)
UicConst_.Enabled = true;
// Load the executable file time
if (!UicConst_.ExecutableTime.Load(UicConst_.Executable)) {
std::string error = "The uic executable ";
error += Quoted(UicConst_.Executable);
error += " does not exist.";
std::string error =
cmStrCat("The uic executable ", Quoted(UicConst_.Executable),
" does not exist.");
return LogInfoError(error);
}
for (std::string& sfl : InfoGetList("AM_UIC_SKIP")) {

43
Source/cmQtAutoRcc.cxx
View File

@ -36,9 +36,7 @@ bool cmQtAutoRcc::Init(cmMakefile* makefile)
this](std::string const& key) -> std::string {
const char* valueConf = nullptr;
{
std::string keyConf = key;
keyConf += '_';
keyConf += InfoConfig();
std::string keyConf = cmStrCat(key, '_', InfoConfig());
valueConf = makefile->GetDefinition(keyConf);
}
if (valueConf == nullptr) {
@ -82,9 +80,8 @@ bool cmQtAutoRcc::Init(cmMakefile* makefile)
// - Rcc executable
RccExecutable_ = InfoGet("ARCC_RCC_EXECUTABLE");
if (!RccExecutableTime_.Load(RccExecutable_)) {
std::string error = "The rcc executable ";
error += Quoted(RccExecutable_);
error += " does not exist.";
std::string error = cmStrCat("The rcc executable ", Quoted(RccExecutable_),
" does not exist.");
return LogInfoError(error);
}
RccListOptions_ = InfoGetList("ARCC_RCC_LIST_OPTIONS");
@ -179,10 +176,8 @@ bool cmQtAutoRcc::Process()
std::string cmQtAutoRcc::MultiConfigOutput() const
{
static std::string const suffix = "_CMAKE_";
std::string res;
res += RccPathChecksum_;
res += '/';
res += AppendFilenameSuffix(RccFileName_, suffix);
std::string res = cmStrCat(RccPathChecksum_, '/',
AppendFilenameSuffix(RccFileName_, suffix));
return res;
}
@ -273,9 +268,7 @@ bool cmQtAutoRcc::SettingsFileWrite()
Log().Info(GenT::RCC, "Writing settings file " + Quoted(SettingsFile_));
}
// Write settings file
std::string content = "rcc:";
content += SettingsString_;
content += '\n';
std::string content = cmStrCat("rcc:", SettingsString_, '\n');
std::string error;
if (!FileWrite(SettingsFile_, content, &error)) {
Log().ErrorFile(GenT::RCC, SettingsFile_,
@ -403,10 +396,9 @@ bool cmQtAutoRcc::TestInfoFile()
// Test if the rcc output file is older than the info file
if (RccFileTime_.Older(InfoFileTime())) {
if (Log().Verbose()) {
std::string reason = "Touching ";
reason += Quoted(RccFileOutput_);
reason += " because it is older than ";
reason += Quoted(InfoFile());
std::string reason =
cmStrCat("Touching ", Quoted(RccFileOutput_),
" because it is older than ", Quoted(InfoFile()));
Log().Info(GenT::RCC, reason);
}
// Touch build file
@ -457,10 +449,9 @@ bool cmQtAutoRcc::GenerateRcc()
if (!result || (retVal != 0)) {
// rcc process failed
{
std::string err = "The rcc process failed to compile\n ";
err += Quoted(QrcFile_);
err += "\ninto\n ";
err += Quoted(RccFileOutput_);
std::string err =
cmStrCat("The rcc process failed to compile\n ", Quoted(QrcFile_),
"\ninto\n ", Quoted(RccFileOutput_));
Log().ErrorCommand(GenT::RCC, err, cmd, rccStdOut + rccStdErr);
}
cmSystemTools::RemoveFile(RccFileOutput_);
@ -482,12 +473,10 @@ bool cmQtAutoRcc::GenerateWrapper()
// Generate a wrapper source file on demand
if (IsMultiConfig()) {
// Wrapper file content
std::string content;
content += "// This is an autogenerated configuration wrapper file.\n";
content += "// Changes will be overwritten.\n";
content += "#include <";
content += MultiConfigOutput();
content += ">\n";
std::string content =
cmStrCat("// This is an autogenerated configuration wrapper file.\n",
"// Changes will be overwritten.\n", "#include <",
MultiConfigOutput(), ">\n");
// Compare with existing file content
bool fileDiffers = true;