mirror of
https://github.com/Kitware/CMake.git
synced 2026-01-06 05:40:54 -06:00
9794b72d38
Don't pass the desired worker thread count to the `cmWorkerPool::Process()` method but set it separately with the new `cmWorkerPool::SetThreadCount` method. This allows calling `cmWorkerPool::Process()` repeatedly without having to pass the thread count every time.
1746 lines
53 KiB
C++
1746 lines
53 KiB
C++
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
file Copyright.txt or https://cmake.org/licensing for details. */
|
|
#include "cmQtAutoMocUic.h"
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <deque>
|
|
#include <list>
|
|
#include <memory>
|
|
#include <set>
|
|
#include <sstream>
|
|
#include <utility>
|
|
|
|
#include "cmAlgorithms.h"
|
|
#include "cmCryptoHash.h"
|
|
#include "cmMakefile.h"
|
|
#include "cmQtAutoGen.h"
|
|
#include "cmSystemTools.h"
|
|
#include "cmake.h"
|
|
|
|
#if defined(__APPLE__)
|
|
# include <unistd.h>
|
|
#endif
|
|
|
|
// -- Class methods
|
|
|
|
std::string cmQtAutoMocUic::BaseSettingsT::AbsoluteBuildPath(
|
|
std::string const& relativePath) const
|
|
{
|
|
return FileSys->CollapseFullPath(relativePath, AutogenBuildDir);
|
|
}
|
|
|
|
/**
|
|
* @brief Tries to find the header file to the given file base path by
|
|
* appending different header extensions
|
|
* @return True on success
|
|
*/
|
|
bool cmQtAutoMocUic::BaseSettingsT::FindHeader(
|
|
std::string& header, std::string const& testBasePath) const
|
|
{
|
|
for (std::string const& ext : HeaderExtensions) {
|
|
std::string testFilePath(testBasePath);
|
|
testFilePath.push_back('.');
|
|
testFilePath += ext;
|
|
if (FileSys->FileExists(testFilePath)) {
|
|
header = testFilePath;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool cmQtAutoMocUic::MocSettingsT::skipped(std::string const& fileName) const
|
|
{
|
|
return (!Enabled || (SkipList.find(fileName) != SkipList.end()));
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the first relevant Qt macro name found in the given C++ code
|
|
* @return The name of the Qt macro or an empty string
|
|
*/
|
|
std::string cmQtAutoMocUic::MocSettingsT::FindMacro(
|
|
std::string const& content) const
|
|
{
|
|
for (KeyExpT const& filter : MacroFilters) {
|
|
// Run a simple find string operation before the expensive
|
|
// regular expression check
|
|
if (content.find(filter.Key) != std::string::npos) {
|
|
cmsys::RegularExpressionMatch match;
|
|
if (filter.Exp.find(content.c_str(), match)) {
|
|
// Return macro name on demand
|
|
return filter.Key;
|
|
}
|
|
}
|
|
}
|
|
return std::string();
|
|
}
|
|
|
|
std::string cmQtAutoMocUic::MocSettingsT::MacrosString() const
|
|
{
|
|
std::string res;
|
|
const auto itB = MacroFilters.cbegin();
|
|
const auto itE = MacroFilters.cend();
|
|
const auto itL = itE - 1;
|
|
auto itC = itB;
|
|
for (; itC != itE; ++itC) {
|
|
// Separator
|
|
if (itC != itB) {
|
|
if (itC != itL) {
|
|
res += ", ";
|
|
} else {
|
|
res += " or ";
|
|
}
|
|
}
|
|
// Key
|
|
res += itC->Key;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
std::string cmQtAutoMocUic::MocSettingsT::FindIncludedFile(
|
|
std::string const& sourcePath, std::string const& includeString) const
|
|
{
|
|
// Search in vicinity of the source
|
|
{
|
|
std::string testPath = sourcePath;
|
|
testPath += includeString;
|
|
if (FileSys->FileExists(testPath)) {
|
|
return FileSys->GetRealPath(testPath);
|
|
}
|
|
}
|
|
// Search in include directories
|
|
for (std::string const& path : IncludePaths) {
|
|
std::string fullPath = path;
|
|
fullPath.push_back('/');
|
|
fullPath += includeString;
|
|
if (FileSys->FileExists(fullPath)) {
|
|
return FileSys->GetRealPath(fullPath);
|
|
}
|
|
}
|
|
// Return empty string
|
|
return std::string();
|
|
}
|
|
|
|
void cmQtAutoMocUic::MocSettingsT::FindDependencies(
|
|
std::string const& content, std::set<std::string>& depends) const
|
|
{
|
|
if (!DependFilters.empty() && !content.empty()) {
|
|
for (KeyExpT const& filter : DependFilters) {
|
|
// Run a simple find string check
|
|
if (content.find(filter.Key) != std::string::npos) {
|
|
// Run the expensive regular expression check loop
|
|
const char* contentChars = content.c_str();
|
|
cmsys::RegularExpressionMatch match;
|
|
while (filter.Exp.find(contentChars, match)) {
|
|
{
|
|
std::string dep = match.match(1);
|
|
if (!dep.empty()) {
|
|
depends.emplace(std::move(dep));
|
|
}
|
|
}
|
|
contentChars += match.end();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool cmQtAutoMocUic::UicSettingsT::skipped(std::string const& fileName) const
|
|
{
|
|
return (!Enabled || (SkipList.find(fileName) != SkipList.end()));
|
|
}
|
|
|
|
void cmQtAutoMocUic::JobT::LogError(GenT genType,
|
|
std::string const& message) const
|
|
{
|
|
Gen()->AbortError();
|
|
Gen()->Log().Error(genType, message);
|
|
}
|
|
|
|
void cmQtAutoMocUic::JobT::LogFileError(GenT genType,
|
|
std::string const& filename,
|
|
std::string const& message) const
|
|
{
|
|
Gen()->AbortError();
|
|
Gen()->Log().ErrorFile(genType, filename, message);
|
|
}
|
|
|
|
void cmQtAutoMocUic::JobT::LogCommandError(
|
|
GenT genType, std::string const& message,
|
|
std::vector<std::string> const& command, std::string const& output) const
|
|
{
|
|
Gen()->AbortError();
|
|
Gen()->Log().ErrorCommand(genType, message, command, output);
|
|
}
|
|
|
|
bool cmQtAutoMocUic::JobT::RunProcess(GenT genType,
|
|
cmWorkerPool::ProcessResultT& result,
|
|
std::vector<std::string> const& command)
|
|
{
|
|
// Log command
|
|
if (Log().Verbose()) {
|
|
std::string msg = "Running command:\n";
|
|
msg += QuotedCommand(command);
|
|
msg += '\n';
|
|
Log().Info(genType, msg);
|
|
}
|
|
return cmWorkerPool::JobT::RunProcess(result, command,
|
|
Gen()->Base().AutogenBuildDir);
|
|
}
|
|
|
|
void cmQtAutoMocUic::JobMocPredefsT::Process()
|
|
{
|
|
// (Re)generate moc_predefs.h on demand
|
|
bool generate(false);
|
|
bool fileExists(FileSys().FileExists(Gen()->Moc().PredefsFileAbs));
|
|
if (!fileExists) {
|
|
if (Log().Verbose()) {
|
|
std::string reason = "Generating ";
|
|
reason += Quoted(Gen()->Moc().PredefsFileRel);
|
|
reason += " because it doesn't exist";
|
|
Log().Info(GenT::MOC, reason);
|
|
}
|
|
generate = true;
|
|
} else if (Gen()->Moc().SettingsChanged) {
|
|
if (Log().Verbose()) {
|
|
std::string reason = "Generating ";
|
|
reason += Quoted(Gen()->Moc().PredefsFileRel);
|
|
reason += " because the settings changed.";
|
|
Log().Info(GenT::MOC, reason);
|
|
}
|
|
generate = true;
|
|
}
|
|
if (generate) {
|
|
cmWorkerPool::ProcessResultT result;
|
|
{
|
|
// Compose command
|
|
std::vector<std::string> cmd = Gen()->Moc().PredefsCmd;
|
|
// Add includes
|
|
cmd.insert(cmd.end(), Gen()->Moc().Includes.begin(),
|
|
Gen()->Moc().Includes.end());
|
|
// Add definitions
|
|
for (std::string const& def : Gen()->Moc().Definitions) {
|
|
cmd.push_back("-D" + def);
|
|
}
|
|
// Execute command
|
|
if (!RunProcess(GenT::MOC, result, cmd)) {
|
|
std::string emsg = "The content generation command for ";
|
|
emsg += Quoted(Gen()->Moc().PredefsFileRel);
|
|
emsg += " failed.\n";
|
|
emsg += result.ErrorMessage;
|
|
LogCommandError(GenT::MOC, emsg, cmd, result.StdOut);
|
|
}
|
|
}
|
|
|
|
// (Re)write predefs file only on demand
|
|
if (!result.error()) {
|
|
if (!fileExists ||
|
|
FileSys().FileDiffers(Gen()->Moc().PredefsFileAbs, result.StdOut)) {
|
|
if (FileSys().FileWrite(Gen()->Moc().PredefsFileAbs, result.StdOut)) {
|
|
// Success
|
|
} else {
|
|
std::string emsg = "Writing ";
|
|
emsg += Quoted(Gen()->Moc().PredefsFileRel);
|
|
emsg += " failed.";
|
|
LogFileError(GenT::MOC, Gen()->Moc().PredefsFileAbs, emsg);
|
|
}
|
|
} else {
|
|
// Touch to update the time stamp
|
|
if (Log().Verbose()) {
|
|
std::string msg = "Touching ";
|
|
msg += Quoted(Gen()->Moc().PredefsFileRel);
|
|
msg += ".";
|
|
Log().Info(GenT::MOC, msg);
|
|
}
|
|
FileSys().Touch(Gen()->Moc().PredefsFileAbs);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void cmQtAutoMocUic::JobParseT::Process()
|
|
{
|
|
if (AutoMoc && Header) {
|
|
// Don't parse header for moc if the file is included by a source already
|
|
if (Gen()->ParallelMocIncluded(FileName)) {
|
|
AutoMoc = false;
|
|
}
|
|
}
|
|
|
|
if (AutoMoc || AutoUic) {
|
|
std::string error;
|
|
MetaT meta;
|
|
if (FileSys().FileRead(meta.Content, FileName, &error)) {
|
|
if (!meta.Content.empty()) {
|
|
meta.FileDir = FileSys().SubDirPrefix(FileName);
|
|
meta.FileBase = FileSys().GetFilenameWithoutLastExtension(FileName);
|
|
|
|
bool success = true;
|
|
if (AutoMoc) {
|
|
if (Header) {
|
|
success = ParseMocHeader(meta);
|
|
} else {
|
|
success = ParseMocSource(meta);
|
|
}
|
|
}
|
|
if (AutoUic && success) {
|
|
ParseUic(meta);
|
|
}
|
|
} else {
|
|
Log().WarningFile(GenT::GEN, FileName, "The source file is empty");
|
|
}
|
|
} else {
|
|
LogFileError(GenT::GEN, FileName, "Could not read the file: " + error);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool cmQtAutoMocUic::JobParseT::ParseMocSource(MetaT const& meta)
|
|
{
|
|
struct JobPre
|
|
{
|
|
bool self; // source file is self
|
|
bool underscore; // "moc_" style include
|
|
std::string SourceFile;
|
|
std::string IncludeString;
|
|
};
|
|
|
|
struct MocInclude
|
|
{
|
|
std::string Inc; // full include string
|
|
std::string Dir; // include string directory
|
|
std::string Base; // include string file base
|
|
};
|
|
|
|
// Check if this source file contains a relevant macro
|
|
std::string const ownMacro = Gen()->Moc().FindMacro(meta.Content);
|
|
|
|
// Extract moc includes from file
|
|
std::deque<MocInclude> mocIncsUsc;
|
|
std::deque<MocInclude> mocIncsDot;
|
|
{
|
|
if (meta.Content.find("moc") != std::string::npos) {
|
|
const char* contentChars = meta.Content.c_str();
|
|
cmsys::RegularExpressionMatch match;
|
|
while (Gen()->Moc().RegExpInclude.find(contentChars, match)) {
|
|
std::string incString = match.match(2);
|
|
std::string incDir(FileSys().SubDirPrefix(incString));
|
|
std::string incBase =
|
|
FileSys().GetFilenameWithoutLastExtension(incString);
|
|
if (cmHasLiteralPrefix(incBase, "moc_")) {
|
|
// moc_<BASE>.cxx
|
|
// Remove the moc_ part from the base name
|
|
mocIncsUsc.emplace_back(MocInclude{
|
|
std::move(incString), std::move(incDir), incBase.substr(4) });
|
|
} else {
|
|
// <BASE>.moc
|
|
mocIncsDot.emplace_back(MocInclude{
|
|
std::move(incString), std::move(incDir), std::move(incBase) });
|
|
}
|
|
// Forward content pointer
|
|
contentChars += match.end();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check if there is anything to do
|
|
if (ownMacro.empty() && mocIncsUsc.empty() && mocIncsDot.empty()) {
|
|
return true;
|
|
}
|
|
|
|
bool ownDotMocIncluded = false;
|
|
bool ownMocUscIncluded = false;
|
|
std::deque<JobPre> jobs;
|
|
|
|
// Process moc_<BASE>.cxx includes
|
|
for (const MocInclude& mocInc : mocIncsUsc) {
|
|
std::string const header =
|
|
MocFindIncludedHeader(meta.FileDir, mocInc.Dir + mocInc.Base);
|
|
if (!header.empty()) {
|
|
// Check if header is skipped
|
|
if (Gen()->Moc().skipped(header)) {
|
|
continue;
|
|
}
|
|
// Register moc job
|
|
const bool ownMoc = (mocInc.Base == meta.FileBase);
|
|
jobs.emplace_back(JobPre{ ownMoc, true, header, mocInc.Inc });
|
|
// Store meta information for relaxed mode
|
|
if (ownMoc) {
|
|
ownMocUscIncluded = true;
|
|
}
|
|
} else {
|
|
{
|
|
std::string emsg = "The file includes the moc file ";
|
|
emsg += Quoted(mocInc.Inc);
|
|
emsg += ", but the header ";
|
|
emsg += Quoted(MocStringHeaders(mocInc.Base));
|
|
emsg += " could not be found.";
|
|
LogFileError(GenT::MOC, FileName, emsg);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Process <BASE>.moc includes
|
|
for (const MocInclude& mocInc : mocIncsDot) {
|
|
const bool ownMoc = (mocInc.Base == meta.FileBase);
|
|
if (Gen()->Moc().RelaxedMode) {
|
|
// Relaxed mode
|
|
if (!ownMacro.empty() && ownMoc) {
|
|
// Add self
|
|
jobs.emplace_back(JobPre{ ownMoc, false, FileName, mocInc.Inc });
|
|
ownDotMocIncluded = true;
|
|
} else {
|
|
// In relaxed mode try to find a header instead but issue a warning.
|
|
// This is for KDE4 compatibility
|
|
std::string const header =
|
|
MocFindIncludedHeader(meta.FileDir, mocInc.Dir + mocInc.Base);
|
|
if (!header.empty()) {
|
|
// Check if header is skipped
|
|
if (Gen()->Moc().skipped(header)) {
|
|
continue;
|
|
}
|
|
// Register moc job
|
|
jobs.emplace_back(JobPre{ ownMoc, false, header, mocInc.Inc });
|
|
if (ownMacro.empty()) {
|
|
if (ownMoc) {
|
|
std::string emsg = "The file includes the moc file ";
|
|
emsg += Quoted(mocInc.Inc);
|
|
emsg += ", but does not contain a ";
|
|
emsg += Gen()->Moc().MacrosString();
|
|
emsg += " macro.\nRunning moc on\n ";
|
|
emsg += Quoted(header);
|
|
emsg += "!\nBetter include ";
|
|
emsg += Quoted("moc_" + mocInc.Base + ".cpp");
|
|
emsg += " for a compatibility with strict mode.\n"
|
|
"(CMAKE_AUTOMOC_RELAXED_MODE warning)\n";
|
|
Log().WarningFile(GenT::MOC, FileName, emsg);
|
|
} else {
|
|
std::string emsg = "The file includes the moc file ";
|
|
emsg += Quoted(mocInc.Inc);
|
|
emsg += " instead of ";
|
|
emsg += Quoted("moc_" + mocInc.Base + ".cpp");
|
|
emsg += ".\nRunning moc on\n ";
|
|
emsg += Quoted(header);
|
|
emsg += "!\nBetter include ";
|
|
emsg += Quoted("moc_" + mocInc.Base + ".cpp");
|
|
emsg += " for compatibility with strict mode.\n"
|
|
"(CMAKE_AUTOMOC_RELAXED_MODE warning)\n";
|
|
Log().WarningFile(GenT::MOC, FileName, emsg);
|
|
}
|
|
}
|
|
} else {
|
|
{
|
|
std::string emsg = "The file includes the moc file ";
|
|
emsg += Quoted(mocInc.Inc);
|
|
emsg += ", which seems to be the moc file from a different "
|
|
"source file.\nCMAKE_AUTOMOC_RELAXED_MODE: Also a "
|
|
"matching header ";
|
|
emsg += Quoted(MocStringHeaders(mocInc.Base));
|
|
emsg += " could not be found.";
|
|
LogFileError(GenT::MOC, FileName, emsg);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
// Strict mode
|
|
if (ownMoc) {
|
|
// Include self
|
|
jobs.emplace_back(JobPre{ ownMoc, false, FileName, mocInc.Inc });
|
|
ownDotMocIncluded = true;
|
|
// Accept but issue a warning if moc isn't required
|
|
if (ownMacro.empty()) {
|
|
std::string emsg = "The file includes the moc file ";
|
|
emsg += Quoted(mocInc.Inc);
|
|
emsg += ", but does not contain a ";
|
|
emsg += Gen()->Moc().MacrosString();
|
|
emsg += " macro.";
|
|
Log().WarningFile(GenT::MOC, FileName, emsg);
|
|
}
|
|
} else {
|
|
// Don't allow <BASE>.moc include other than self in strict mode
|
|
{
|
|
std::string emsg = "The file includes the moc file ";
|
|
emsg += Quoted(mocInc.Inc);
|
|
emsg += ", which seems to be the moc file from a different "
|
|
"source file.\nThis is not supported. Include ";
|
|
emsg += Quoted(meta.FileBase + ".moc");
|
|
emsg += " to run moc on this source file.";
|
|
LogFileError(GenT::MOC, FileName, emsg);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!ownMacro.empty() && !ownDotMocIncluded) {
|
|
// In this case, check whether the scanned file itself contains a
|
|
// Q_OBJECT.
|
|
// If this is the case, the moc_foo.cpp should probably be generated from
|
|
// foo.cpp instead of foo.h, because otherwise it won't build.
|
|
// But warn, since this is not how it is supposed to be used.
|
|
// This is for KDE4 compatibility.
|
|
if (Gen()->Moc().RelaxedMode && ownMocUscIncluded) {
|
|
JobPre uscJobPre;
|
|
// Remove underscore job request
|
|
{
|
|
auto itC = jobs.begin();
|
|
auto itE = jobs.end();
|
|
for (; itC != itE; ++itC) {
|
|
JobPre& job(*itC);
|
|
if (job.self && job.underscore) {
|
|
uscJobPre = std::move(job);
|
|
jobs.erase(itC);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// Issue a warning
|
|
{
|
|
std::string emsg = "The file contains a ";
|
|
emsg += ownMacro;
|
|
emsg += " macro, but does not include ";
|
|
emsg += Quoted(meta.FileBase + ".moc");
|
|
emsg += ". Instead it includes ";
|
|
emsg += Quoted(uscJobPre.IncludeString);
|
|
emsg += ".\nRunning moc on\n ";
|
|
emsg += Quoted(FileName);
|
|
emsg += "!\nBetter include ";
|
|
emsg += Quoted(meta.FileBase + ".moc");
|
|
emsg += " for compatibility with strict mode.\n"
|
|
"(CMAKE_AUTOMOC_RELAXED_MODE warning)";
|
|
Log().WarningFile(GenT::MOC, FileName, emsg);
|
|
}
|
|
// Add own source job
|
|
jobs.emplace_back(
|
|
JobPre{ true, false, FileName, uscJobPre.IncludeString });
|
|
} else {
|
|
// Otherwise always error out since it will not compile.
|
|
{
|
|
std::string emsg = "The file contains a ";
|
|
emsg += ownMacro;
|
|
emsg += " macro, but does not include ";
|
|
emsg += Quoted(meta.FileBase + ".moc");
|
|
emsg += "!\nConsider to\n - add #include \"";
|
|
emsg += meta.FileBase;
|
|
emsg += ".moc\"\n - enable SKIP_AUTOMOC for this file";
|
|
LogFileError(GenT::MOC, FileName, emsg);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Convert pre jobs to actual jobs
|
|
for (JobPre& jobPre : jobs) {
|
|
cmWorkerPool::JobHandleT jobHandle = cm::make_unique<JobMocT>(
|
|
std::move(jobPre.SourceFile), FileName, std::move(jobPre.IncludeString));
|
|
if (jobPre.self) {
|
|
// Read dependencies from this source
|
|
JobMocT& jobMoc = static_cast<JobMocT&>(*jobHandle);
|
|
Gen()->Moc().FindDependencies(meta.Content, jobMoc.Depends);
|
|
jobMoc.DependsValid = true;
|
|
}
|
|
if (!Gen()->ParallelJobPushMoc(std::move(jobHandle))) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool cmQtAutoMocUic::JobParseT::ParseMocHeader(MetaT const& meta)
|
|
{
|
|
bool success = true;
|
|
std::string const macroName = Gen()->Moc().FindMacro(meta.Content);
|
|
if (!macroName.empty()) {
|
|
cmWorkerPool::JobHandleT jobHandle = cm::make_unique<JobMocT>(
|
|
std::string(FileName), std::string(), std::string());
|
|
// Read dependencies from this source
|
|
{
|
|
JobMocT& jobMoc = static_cast<JobMocT&>(*jobHandle);
|
|
Gen()->Moc().FindDependencies(meta.Content, jobMoc.Depends);
|
|
jobMoc.DependsValid = true;
|
|
}
|
|
success = Gen()->ParallelJobPushMoc(std::move(jobHandle));
|
|
}
|
|
return success;
|
|
}
|
|
|
|
std::string cmQtAutoMocUic::JobParseT::MocStringHeaders(
|
|
std::string const& fileBase) const
|
|
{
|
|
std::string res = fileBase;
|
|
res += ".{";
|
|
res += cmJoin(Gen()->Base().HeaderExtensions, ",");
|
|
res += "}";
|
|
return res;
|
|
}
|
|
|
|
std::string cmQtAutoMocUic::JobParseT::MocFindIncludedHeader(
|
|
std::string const& includerDir, std::string const& includeBase)
|
|
{
|
|
std::string header;
|
|
// Search in vicinity of the source
|
|
if (!Gen()->Base().FindHeader(header, includerDir + includeBase)) {
|
|
// Search in include directories
|
|
for (std::string const& path : Gen()->Moc().IncludePaths) {
|
|
std::string fullPath = path;
|
|
fullPath.push_back('/');
|
|
fullPath += includeBase;
|
|
if (Gen()->Base().FindHeader(header, fullPath)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// Sanitize
|
|
if (!header.empty()) {
|
|
header = FileSys().GetRealPath(header);
|
|
}
|
|
return header;
|
|
}
|
|
|
|
bool cmQtAutoMocUic::JobParseT::ParseUic(MetaT const& meta)
|
|
{
|
|
bool success = true;
|
|
if (meta.Content.find("ui_") != std::string::npos) {
|
|
const char* contentChars = meta.Content.c_str();
|
|
cmsys::RegularExpressionMatch match;
|
|
while (Gen()->Uic().RegExpInclude.find(contentChars, match)) {
|
|
if (!ParseUicInclude(meta, match.match(2))) {
|
|
success = false;
|
|
break;
|
|
}
|
|
contentChars += match.end();
|
|
}
|
|
}
|
|
return success;
|
|
}
|
|
|
|
bool cmQtAutoMocUic::JobParseT::ParseUicInclude(MetaT const& meta,
|
|
std::string&& includeString)
|
|
{
|
|
bool success = false;
|
|
std::string uiInputFile = UicFindIncludedFile(meta, includeString);
|
|
if (!uiInputFile.empty()) {
|
|
if (!Gen()->Uic().skipped(uiInputFile)) {
|
|
cmWorkerPool::JobHandleT jobHandle = cm::make_unique<JobUicT>(
|
|
std::move(uiInputFile), FileName, std::move(includeString));
|
|
success = Gen()->ParallelJobPushUic(std::move(jobHandle));
|
|
} else {
|
|
// A skipped file is successful
|
|
success = true;
|
|
}
|
|
}
|
|
return success;
|
|
}
|
|
|
|
std::string cmQtAutoMocUic::JobParseT::UicFindIncludedFile(
|
|
MetaT const& meta, std::string const& includeString)
|
|
{
|
|
std::string res;
|
|
std::string searchFile =
|
|
FileSys().GetFilenameWithoutLastExtension(includeString).substr(3);
|
|
searchFile += ".ui";
|
|
// Collect search paths list
|
|
std::deque<std::string> testFiles;
|
|
{
|
|
std::string const searchPath = FileSys().SubDirPrefix(includeString);
|
|
|
|
std::string searchFileFull;
|
|
if (!searchPath.empty()) {
|
|
searchFileFull = searchPath;
|
|
searchFileFull += searchFile;
|
|
}
|
|
// Vicinity of the source
|
|
{
|
|
std::string const sourcePath = meta.FileDir;
|
|
testFiles.push_back(sourcePath + searchFile);
|
|
if (!searchPath.empty()) {
|
|
testFiles.push_back(sourcePath + searchFileFull);
|
|
}
|
|
}
|
|
// AUTOUIC search paths
|
|
if (!Gen()->Uic().SearchPaths.empty()) {
|
|
for (std::string const& sPath : Gen()->Uic().SearchPaths) {
|
|
testFiles.push_back((sPath + "/").append(searchFile));
|
|
}
|
|
if (!searchPath.empty()) {
|
|
for (std::string const& sPath : Gen()->Uic().SearchPaths) {
|
|
testFiles.push_back((sPath + "/").append(searchFileFull));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Search for the .ui file!
|
|
for (std::string const& testFile : testFiles) {
|
|
if (FileSys().FileExists(testFile)) {
|
|
res = FileSys().GetRealPath(testFile);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Log error
|
|
if (res.empty()) {
|
|
std::string emsg = "Could not find ";
|
|
emsg += Quoted(searchFile);
|
|
emsg += " in\n";
|
|
for (std::string const& testFile : testFiles) {
|
|
emsg += " ";
|
|
emsg += Quoted(testFile);
|
|
emsg += "\n";
|
|
}
|
|
LogFileError(GenT::UIC, FileName, emsg);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
void cmQtAutoMocUic::JobPostParseT::Process()
|
|
{
|
|
if (Gen()->Moc().Enabled) {
|
|
// Add mocs compilations fence job
|
|
Gen()->WorkerPool().EmplaceJob<JobMocsCompilationT>();
|
|
}
|
|
// Add finish job
|
|
Gen()->WorkerPool().EmplaceJob<JobFinishT>();
|
|
}
|
|
|
|
void cmQtAutoMocUic::JobMocsCompilationT::Process()
|
|
{
|
|
// Compose mocs compilation file content
|
|
std::string content =
|
|
"// This file is autogenerated. Changes will be overwritten.\n";
|
|
if (Gen()->MocAutoFiles().empty()) {
|
|
// Placeholder content
|
|
content += "// No files found that require moc or the moc files are "
|
|
"included\n";
|
|
content += "enum some_compilers { need_more_than_nothing };\n";
|
|
} else {
|
|
// Valid content
|
|
char const sbeg = Gen()->Base().MultiConfig ? '<' : '"';
|
|
char const send = Gen()->Base().MultiConfig ? '>' : '"';
|
|
for (std::string const& mocfile : Gen()->MocAutoFiles()) {
|
|
content += "#include ";
|
|
content += sbeg;
|
|
content += mocfile;
|
|
content += send;
|
|
content += '\n';
|
|
}
|
|
}
|
|
|
|
std::string const& compAbs = Gen()->Moc().CompFileAbs;
|
|
if (FileSys().FileDiffers(compAbs, content)) {
|
|
// Actually write mocs compilation file
|
|
if (Log().Verbose()) {
|
|
Log().Info(GenT::MOC, "Generating MOC compilation " + compAbs);
|
|
}
|
|
if (!FileSys().FileWrite(compAbs, content)) {
|
|
LogFileError(GenT::MOC, compAbs,
|
|
"mocs compilation file writing failed.");
|
|
}
|
|
} else if (Gen()->MocAutoFileUpdated()) {
|
|
// Only touch mocs compilation file
|
|
if (Log().Verbose()) {
|
|
Log().Info(GenT::MOC, "Touching mocs compilation " + compAbs);
|
|
}
|
|
FileSys().Touch(compAbs);
|
|
}
|
|
}
|
|
|
|
void cmQtAutoMocUic::JobMocT::FindDependencies(std::string const& content)
|
|
{
|
|
Gen()->Moc().FindDependencies(content, Depends);
|
|
DependsValid = true;
|
|
}
|
|
|
|
void cmQtAutoMocUic::JobMocT::Process()
|
|
{
|
|
// Compute build file name
|
|
if (!IncludeString.empty()) {
|
|
BuildFile = Gen()->Base().AutogenIncludeDir;
|
|
BuildFile += '/';
|
|
BuildFile += IncludeString;
|
|
} else {
|
|
// Relative build path
|
|
std::string relPath = FileSys().GetFilePathChecksum(SourceFile);
|
|
relPath += "/moc_";
|
|
relPath += FileSys().GetFilenameWithoutLastExtension(SourceFile);
|
|
|
|
// Register relative file path with duplication check
|
|
relPath = Gen()->ParallelMocAutoRegister(relPath);
|
|
|
|
// Absolute build path
|
|
if (Gen()->Base().MultiConfig) {
|
|
BuildFile = Gen()->Base().AutogenIncludeDir;
|
|
BuildFile += '/';
|
|
BuildFile += relPath;
|
|
} else {
|
|
BuildFile = Gen()->Base().AbsoluteBuildPath(relPath);
|
|
}
|
|
}
|
|
|
|
if (UpdateRequired()) {
|
|
GenerateMoc();
|
|
}
|
|
}
|
|
|
|
bool cmQtAutoMocUic::JobMocT::UpdateRequired()
|
|
{
|
|
bool const verbose = Log().Verbose();
|
|
|
|
// Test if the build file exists
|
|
if (!FileSys().FileExists(BuildFile)) {
|
|
if (verbose) {
|
|
std::string reason = "Generating ";
|
|
reason += Quoted(BuildFile);
|
|
reason += " from its source file ";
|
|
reason += Quoted(SourceFile);
|
|
reason += " because it doesn't exist";
|
|
Log().Info(GenT::MOC, reason);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Test if any setting changed
|
|
if (Gen()->Moc().SettingsChanged) {
|
|
if (verbose) {
|
|
std::string reason = "Generating ";
|
|
reason += Quoted(BuildFile);
|
|
reason += " from ";
|
|
reason += Quoted(SourceFile);
|
|
reason += " because the MOC settings changed";
|
|
Log().Info(GenT::MOC, reason);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Test if the moc_predefs file is newer
|
|
if (!Gen()->Moc().PredefsFileAbs.empty()) {
|
|
bool isOlder = false;
|
|
{
|
|
std::string error;
|
|
isOlder = FileSys().FileIsOlderThan(BuildFile,
|
|
Gen()->Moc().PredefsFileAbs, &error);
|
|
if (!isOlder && !error.empty()) {
|
|
LogError(GenT::MOC, error);
|
|
return false;
|
|
}
|
|
}
|
|
if (isOlder) {
|
|
if (verbose) {
|
|
std::string reason = "Generating ";
|
|
reason += Quoted(BuildFile);
|
|
reason += " because it's older than: ";
|
|
reason += Quoted(Gen()->Moc().PredefsFileAbs);
|
|
Log().Info(GenT::MOC, reason);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Test if the source file is newer
|
|
{
|
|
bool isOlder = false;
|
|
{
|
|
std::string error;
|
|
isOlder = FileSys().FileIsOlderThan(BuildFile, SourceFile, &error);
|
|
if (!isOlder && !error.empty()) {
|
|
LogError(GenT::MOC, error);
|
|
return false;
|
|
}
|
|
}
|
|
if (isOlder) {
|
|
if (verbose) {
|
|
std::string reason = "Generating ";
|
|
reason += Quoted(BuildFile);
|
|
reason += " because it's older than its source file ";
|
|
reason += Quoted(SourceFile);
|
|
Log().Info(GenT::MOC, reason);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Test if a dependency file is newer
|
|
{
|
|
// Read dependencies on demand
|
|
if (!DependsValid) {
|
|
std::string content;
|
|
{
|
|
std::string error;
|
|
if (!FileSys().FileRead(content, SourceFile, &error)) {
|
|
std::string emsg = "Could not read file\n ";
|
|
emsg += Quoted(SourceFile);
|
|
emsg += "\nrequired by moc include ";
|
|
emsg += Quoted(IncludeString);
|
|
emsg += " in\n ";
|
|
emsg += Quoted(IncluderFile);
|
|
emsg += ".\n";
|
|
emsg += error;
|
|
LogError(GenT::MOC, emsg);
|
|
return false;
|
|
}
|
|
}
|
|
FindDependencies(content);
|
|
}
|
|
// Check dependency timestamps
|
|
std::string error;
|
|
std::string sourceDir = FileSys().SubDirPrefix(SourceFile);
|
|
for (std::string const& depFileRel : Depends) {
|
|
std::string depFileAbs =
|
|
Gen()->Moc().FindIncludedFile(sourceDir, depFileRel);
|
|
if (!depFileAbs.empty()) {
|
|
if (FileSys().FileIsOlderThan(BuildFile, depFileAbs, &error)) {
|
|
if (verbose) {
|
|
std::string reason = "Generating ";
|
|
reason += Quoted(BuildFile);
|
|
reason += " from ";
|
|
reason += Quoted(SourceFile);
|
|
reason += " because it is older than it's dependency file ";
|
|
reason += Quoted(depFileAbs);
|
|
Log().Info(GenT::MOC, reason);
|
|
}
|
|
return true;
|
|
}
|
|
if (!error.empty()) {
|
|
LogError(GenT::MOC, error);
|
|
return false;
|
|
}
|
|
} else {
|
|
std::string message = "Could not find dependency file ";
|
|
message += Quoted(depFileRel);
|
|
Log().WarningFile(GenT::MOC, SourceFile, message);
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void cmQtAutoMocUic::JobMocT::GenerateMoc()
|
|
{
|
|
// Make sure the parent directory exists
|
|
if (!FileSys().MakeParentDirectory(BuildFile)) {
|
|
LogFileError(GenT::MOC, BuildFile, "Could not create parent directory.");
|
|
return;
|
|
}
|
|
{
|
|
// Compose moc command
|
|
std::vector<std::string> cmd;
|
|
cmd.push_back(Gen()->Moc().Executable);
|
|
// Add options
|
|
cmd.insert(cmd.end(), Gen()->Moc().AllOptions.begin(),
|
|
Gen()->Moc().AllOptions.end());
|
|
// Add predefs include
|
|
if (!Gen()->Moc().PredefsFileAbs.empty()) {
|
|
cmd.emplace_back("--include");
|
|
cmd.push_back(Gen()->Moc().PredefsFileAbs);
|
|
}
|
|
cmd.emplace_back("-o");
|
|
cmd.push_back(BuildFile);
|
|
cmd.push_back(SourceFile);
|
|
|
|
// Execute moc command
|
|
cmWorkerPool::ProcessResultT result;
|
|
if (RunProcess(GenT::MOC, result, cmd)) {
|
|
// Moc command success
|
|
// Print moc output
|
|
if (!result.StdOut.empty()) {
|
|
Log().Info(GenT::MOC, result.StdOut);
|
|
}
|
|
// Notify the generator that a not included file changed (on demand)
|
|
if (IncludeString.empty()) {
|
|
Gen()->ParallelMocAutoUpdated();
|
|
}
|
|
} else {
|
|
// Moc command failed
|
|
{
|
|
std::string emsg = "The moc process failed to compile\n ";
|
|
emsg += Quoted(SourceFile);
|
|
emsg += "\ninto\n ";
|
|
emsg += Quoted(BuildFile);
|
|
emsg += ".\n";
|
|
emsg += result.ErrorMessage;
|
|
LogCommandError(GenT::MOC, emsg, cmd, result.StdOut);
|
|
}
|
|
FileSys().FileRemove(BuildFile);
|
|
}
|
|
}
|
|
}
|
|
|
|
void cmQtAutoMocUic::JobUicT::Process()
|
|
{
|
|
// Compute build file name
|
|
BuildFile = Gen()->Base().AutogenIncludeDir;
|
|
BuildFile += '/';
|
|
BuildFile += IncludeString;
|
|
|
|
if (UpdateRequired()) {
|
|
GenerateUic();
|
|
}
|
|
}
|
|
|
|
bool cmQtAutoMocUic::JobUicT::UpdateRequired()
|
|
{
|
|
bool const verbose = Log().Verbose();
|
|
|
|
// Test if the build file exists
|
|
if (!FileSys().FileExists(BuildFile)) {
|
|
if (verbose) {
|
|
std::string reason = "Generating ";
|
|
reason += Quoted(BuildFile);
|
|
reason += " from its source file ";
|
|
reason += Quoted(SourceFile);
|
|
reason += " because it doesn't exist";
|
|
Log().Info(GenT::UIC, reason);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Test if the uic settings changed
|
|
if (Gen()->Uic().SettingsChanged) {
|
|
if (verbose) {
|
|
std::string reason = "Generating ";
|
|
reason += Quoted(BuildFile);
|
|
reason += " from ";
|
|
reason += Quoted(SourceFile);
|
|
reason += " because the UIC settings changed";
|
|
Log().Info(GenT::UIC, reason);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Test if the source file is newer
|
|
{
|
|
bool isOlder = false;
|
|
{
|
|
std::string error;
|
|
isOlder = FileSys().FileIsOlderThan(BuildFile, SourceFile, &error);
|
|
if (!isOlder && !error.empty()) {
|
|
LogError(GenT::UIC, error);
|
|
return false;
|
|
}
|
|
}
|
|
if (isOlder) {
|
|
if (verbose) {
|
|
std::string reason = "Generating ";
|
|
reason += Quoted(BuildFile);
|
|
reason += " because it's older than its source file ";
|
|
reason += Quoted(SourceFile);
|
|
Log().Info(GenT::UIC, reason);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void cmQtAutoMocUic::JobUicT::GenerateUic()
|
|
{
|
|
// Make sure the parent directory exists
|
|
if (!FileSys().MakeParentDirectory(BuildFile)) {
|
|
LogFileError(GenT::UIC, BuildFile, "Could not create parent directory.");
|
|
return;
|
|
}
|
|
{
|
|
// Compose uic command
|
|
std::vector<std::string> cmd;
|
|
cmd.push_back(Gen()->Uic().Executable);
|
|
{
|
|
std::vector<std::string> allOpts = Gen()->Uic().TargetOptions;
|
|
auto optionIt = Gen()->Uic().Options.find(SourceFile);
|
|
if (optionIt != Gen()->Uic().Options.end()) {
|
|
UicMergeOptions(allOpts, optionIt->second,
|
|
(Gen()->Base().QtVersionMajor == 5));
|
|
}
|
|
cmd.insert(cmd.end(), allOpts.begin(), allOpts.end());
|
|
}
|
|
cmd.emplace_back("-o");
|
|
cmd.emplace_back(BuildFile);
|
|
cmd.emplace_back(SourceFile);
|
|
|
|
cmWorkerPool::ProcessResultT result;
|
|
if (RunProcess(GenT::UIC, result, cmd)) {
|
|
// Uic command success
|
|
// Print uic output
|
|
if (!result.StdOut.empty()) {
|
|
Log().Info(GenT::UIC, result.StdOut);
|
|
}
|
|
} else {
|
|
// Uic command failed
|
|
{
|
|
std::string emsg = "The uic process failed to compile\n ";
|
|
emsg += Quoted(SourceFile);
|
|
emsg += "\ninto\n ";
|
|
emsg += Quoted(BuildFile);
|
|
emsg += "\nincluded by\n ";
|
|
emsg += Quoted(IncluderFile);
|
|
emsg += ".\n";
|
|
emsg += result.ErrorMessage;
|
|
LogCommandError(GenT::UIC, emsg, cmd, result.StdOut);
|
|
}
|
|
FileSys().FileRemove(BuildFile);
|
|
}
|
|
}
|
|
}
|
|
|
|
void cmQtAutoMocUic::JobFinishT::Process()
|
|
{
|
|
Gen()->AbortSuccess();
|
|
}
|
|
|
|
cmQtAutoMocUic::cmQtAutoMocUic()
|
|
: Base_(&FileSys())
|
|
, Moc_(&FileSys())
|
|
{
|
|
// Precompile regular expressions
|
|
Moc_.RegExpInclude.compile(
|
|
"(^|\n)[ \t]*#[ \t]*include[ \t]+"
|
|
"[\"<](([^ \">]+/)?moc_[^ \">/]+\\.cpp|[^ \">]+\\.moc)[\">]");
|
|
Uic_.RegExpInclude.compile("(^|\n)[ \t]*#[ \t]*include[ \t]+"
|
|
"[\"<](([^ \">]+/)?ui_[^ \">/]+\\.h)[\">]");
|
|
}
|
|
|
|
cmQtAutoMocUic::~cmQtAutoMocUic() = default;
|
|
|
|
bool cmQtAutoMocUic::Init(cmMakefile* makefile)
|
|
{
|
|
// -- Meta
|
|
Base_.HeaderExtensions = makefile->GetCMakeInstance()->GetHeaderExtensions();
|
|
|
|
// Utility lambdas
|
|
auto InfoGet = [makefile](const char* key) {
|
|
return makefile->GetSafeDefinition(key);
|
|
};
|
|
auto InfoGetBool = [makefile](const char* key) {
|
|
return makefile->IsOn(key);
|
|
};
|
|
auto InfoGetList = [makefile](const char* key) -> std::vector<std::string> {
|
|
std::vector<std::string> list;
|
|
cmSystemTools::ExpandListArgument(makefile->GetSafeDefinition(key), list);
|
|
return list;
|
|
};
|
|
auto InfoGetLists =
|
|
[makefile](const char* key) -> std::vector<std::vector<std::string>> {
|
|
std::vector<std::vector<std::string>> lists;
|
|
{
|
|
std::string const value = makefile->GetSafeDefinition(key);
|
|
std::string::size_type pos = 0;
|
|
while (pos < value.size()) {
|
|
std::string::size_type next = value.find(ListSep, pos);
|
|
std::string::size_type length =
|
|
(next != std::string::npos) ? next - pos : value.size() - pos;
|
|
// Remove enclosing braces
|
|
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));
|
|
}
|
|
}
|
|
pos += length;
|
|
pos += ListSep.size();
|
|
}
|
|
}
|
|
return lists;
|
|
};
|
|
auto InfoGetConfig = [makefile, this](const char* key) -> std::string {
|
|
const char* valueConf = nullptr;
|
|
{
|
|
std::string keyConf = key;
|
|
keyConf += '_';
|
|
keyConf += InfoConfig();
|
|
valueConf = makefile->GetDefinition(keyConf);
|
|
}
|
|
if (valueConf == nullptr) {
|
|
return makefile->GetSafeDefinition(key);
|
|
}
|
|
return std::string(valueConf);
|
|
};
|
|
auto InfoGetConfigList =
|
|
[&InfoGetConfig](const char* key) -> std::vector<std::string> {
|
|
std::vector<std::string> list;
|
|
cmSystemTools::ExpandListArgument(InfoGetConfig(key), list);
|
|
return list;
|
|
};
|
|
|
|
// -- Read info file
|
|
if (!makefile->ReadListFile(InfoFile())) {
|
|
Log().ErrorFile(GenT::GEN, InfoFile(), "File processing failed");
|
|
return false;
|
|
}
|
|
|
|
// -- Meta
|
|
Log().RaiseVerbosity(InfoGet("AM_VERBOSITY"));
|
|
Base_.MultiConfig = InfoGetBool("AM_MULTI_CONFIG");
|
|
{
|
|
unsigned long num = Base_.NumThreads;
|
|
if (cmSystemTools::StringToULong(InfoGet("AM_PARALLEL").c_str(), &num)) {
|
|
num = std::max<unsigned long>(num, 1);
|
|
num = std::min<unsigned long>(num, ParallelMax);
|
|
Base_.NumThreads = static_cast<unsigned int>(num);
|
|
}
|
|
WorkerPool_.SetThreadCount(Base_.NumThreads);
|
|
}
|
|
|
|
// - Files and directories
|
|
Base_.ProjectSourceDir = InfoGet("AM_CMAKE_SOURCE_DIR");
|
|
Base_.ProjectBinaryDir = InfoGet("AM_CMAKE_BINARY_DIR");
|
|
Base_.CurrentSourceDir = InfoGet("AM_CMAKE_CURRENT_SOURCE_DIR");
|
|
Base_.CurrentBinaryDir = InfoGet("AM_CMAKE_CURRENT_BINARY_DIR");
|
|
Base_.IncludeProjectDirsBefore =
|
|
InfoGetBool("AM_CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE");
|
|
Base_.AutogenBuildDir = InfoGet("AM_BUILD_DIR");
|
|
if (Base_.AutogenBuildDir.empty()) {
|
|
Log().ErrorFile(GenT::GEN, InfoFile(), "Autogen build directory missing");
|
|
return false;
|
|
}
|
|
// include directory
|
|
Base_.AutogenIncludeDir = InfoGetConfig("AM_INCLUDE_DIR");
|
|
if (Base_.AutogenIncludeDir.empty()) {
|
|
Log().ErrorFile(GenT::GEN, InfoFile(),
|
|
"Autogen include directory missing");
|
|
return false;
|
|
}
|
|
|
|
// - Files
|
|
SettingsFile_ = InfoGetConfig("AM_SETTINGS_FILE");
|
|
if (SettingsFile_.empty()) {
|
|
Log().ErrorFile(GenT::GEN, InfoFile(), "Settings file name missing");
|
|
return false;
|
|
}
|
|
|
|
// - Qt environment
|
|
{
|
|
unsigned long qtv = Base_.QtVersionMajor;
|
|
if (cmSystemTools::StringToULong(InfoGet("AM_QT_VERSION_MAJOR").c_str(),
|
|
&qtv)) {
|
|
Base_.QtVersionMajor = static_cast<unsigned int>(qtv);
|
|
}
|
|
}
|
|
|
|
// - Moc
|
|
Moc_.Executable = InfoGet("AM_QT_MOC_EXECUTABLE");
|
|
Moc_.Enabled = !Moc().Executable.empty();
|
|
if (Moc().Enabled) {
|
|
for (std::string& sfl : InfoGetList("AM_MOC_SKIP")) {
|
|
Moc_.SkipList.insert(std::move(sfl));
|
|
}
|
|
Moc_.Definitions = InfoGetConfigList("AM_MOC_DEFINITIONS");
|
|
Moc_.IncludePaths = InfoGetConfigList("AM_MOC_INCLUDES");
|
|
Moc_.Options = InfoGetList("AM_MOC_OPTIONS");
|
|
Moc_.RelaxedMode = InfoGetBool("AM_MOC_RELAXED_MODE");
|
|
for (std::string const& item : InfoGetList("AM_MOC_MACRO_NAMES")) {
|
|
Moc_.MacroFilters.emplace_back(
|
|
item, ("[\n][ \t]*{?[ \t]*" + item).append("[^a-zA-Z0-9_]"));
|
|
}
|
|
{
|
|
auto pushFilter = [this](std::string const& key, std::string const& exp,
|
|
std::string& error) {
|
|
if (!key.empty()) {
|
|
if (!exp.empty()) {
|
|
Moc_.DependFilters.emplace_back();
|
|
KeyExpT& filter(Moc_.DependFilters.back());
|
|
if (filter.Exp.compile(exp)) {
|
|
filter.Key = key;
|
|
} else {
|
|
error = "Regular expression compiling failed";
|
|
}
|
|
} else {
|
|
error = "Regular expression is empty";
|
|
}
|
|
} else {
|
|
error = "Key is empty";
|
|
}
|
|
if (!error.empty()) {
|
|
error = ("AUTOMOC_DEPEND_FILTERS: " + error);
|
|
error += "\n";
|
|
error += " Key: ";
|
|
error += Quoted(key);
|
|
error += "\n";
|
|
error += " Exp: ";
|
|
error += Quoted(exp);
|
|
error += "\n";
|
|
}
|
|
};
|
|
|
|
std::string error;
|
|
// Insert default filter for Q_PLUGIN_METADATA
|
|
if (Base().QtVersionMajor != 4) {
|
|
pushFilter("Q_PLUGIN_METADATA",
|
|
"[\n][ \t]*Q_PLUGIN_METADATA[ \t]*\\("
|
|
"[^\\)]*FILE[ \t]*\"([^\"]+)\"",
|
|
error);
|
|
}
|
|
// Insert user defined dependency filters
|
|
{
|
|
std::vector<std::string> flts = InfoGetList("AM_MOC_DEPEND_FILTERS");
|
|
if ((flts.size() % 2) == 0) {
|
|
for (std::vector<std::string>::iterator itC = flts.begin(),
|
|
itE = flts.end();
|
|
itC != itE; itC += 2) {
|
|
pushFilter(*itC, *(itC + 1), error);
|
|
if (!error.empty()) {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
Log().ErrorFile(
|
|
GenT::MOC, InfoFile(),
|
|
"AUTOMOC_DEPEND_FILTERS list size is not a multiple of 2");
|
|
return false;
|
|
}
|
|
}
|
|
if (!error.empty()) {
|
|
Log().ErrorFile(GenT::MOC, InfoFile(), error);
|
|
return false;
|
|
}
|
|
}
|
|
Moc_.PredefsCmd = InfoGetList("AM_MOC_PREDEFS_CMD");
|
|
// Install moc predefs job
|
|
if (!Moc().PredefsCmd.empty()) {
|
|
WorkerPool().EmplaceJob<JobMocPredefsT>();
|
|
}
|
|
}
|
|
|
|
// - Uic
|
|
Uic_.Executable = InfoGet("AM_QT_UIC_EXECUTABLE");
|
|
Uic_.Enabled = !Uic().Executable.empty();
|
|
if (Uic().Enabled) {
|
|
for (std::string& sfl : InfoGetList("AM_UIC_SKIP")) {
|
|
Uic_.SkipList.insert(std::move(sfl));
|
|
}
|
|
Uic_.SearchPaths = InfoGetList("AM_UIC_SEARCH_PATHS");
|
|
Uic_.TargetOptions = InfoGetConfigList("AM_UIC_TARGET_OPTIONS");
|
|
{
|
|
auto sources = InfoGetList("AM_UIC_OPTIONS_FILES");
|
|
auto options = InfoGetLists("AM_UIC_OPTIONS_OPTIONS");
|
|
// Compare list sizes
|
|
if (sources.size() != options.size()) {
|
|
std::ostringstream ost;
|
|
ost << "files/options lists sizes mismatch (" << sources.size() << "/"
|
|
<< options.size() << ")";
|
|
Log().ErrorFile(GenT::UIC, InfoFile(), ost.str());
|
|
return false;
|
|
}
|
|
auto fitEnd = sources.cend();
|
|
auto fit = sources.begin();
|
|
auto oit = options.begin();
|
|
while (fit != fitEnd) {
|
|
Uic_.Options[*fit] = std::move(*oit);
|
|
++fit;
|
|
++oit;
|
|
}
|
|
}
|
|
}
|
|
|
|
// - Headers and sources
|
|
// Add sources
|
|
{
|
|
auto addSource = [this](std::string&& src, bool moc, bool uic) {
|
|
WorkerPool().EmplaceJob<JobParseT>(std::move(src), moc, uic, false);
|
|
};
|
|
for (std::string& src : InfoGetList("AM_SOURCES")) {
|
|
addSource(std::move(src), true, true);
|
|
}
|
|
if (Moc().Enabled) {
|
|
for (std::string& src : InfoGetList("AM_MOC_SOURCES")) {
|
|
addSource(std::move(src), true, false);
|
|
}
|
|
}
|
|
if (Uic().Enabled) {
|
|
for (std::string& src : InfoGetList("AM_UIC_SOURCES")) {
|
|
addSource(std::move(src), false, true);
|
|
}
|
|
}
|
|
}
|
|
// Add Fence job
|
|
WorkerPool().EmplaceJob<JobFenceT>();
|
|
// Add headers
|
|
{
|
|
auto addHeader = [this](std::string&& hdr, bool moc, bool uic) {
|
|
WorkerPool().EmplaceJob<JobParseT>(std::move(hdr), moc, uic, true);
|
|
};
|
|
for (std::string& hdr : InfoGetList("AM_HEADERS")) {
|
|
addHeader(std::move(hdr), true, true);
|
|
}
|
|
if (Moc().Enabled) {
|
|
for (std::string& hdr : InfoGetList("AM_MOC_HEADERS")) {
|
|
addHeader(std::move(hdr), true, false);
|
|
}
|
|
}
|
|
if (Uic().Enabled) {
|
|
for (std::string& hdr : InfoGetList("AM_UIC_HEADERS")) {
|
|
addHeader(std::move(hdr), false, true);
|
|
}
|
|
}
|
|
}
|
|
// Addpost parse fence job
|
|
WorkerPool().EmplaceJob<JobPostParseT>();
|
|
|
|
// Init derived information
|
|
// ------------------------
|
|
|
|
// Init file path checksum generator
|
|
FileSys().setupFilePathChecksum(
|
|
Base().CurrentSourceDir, Base().CurrentBinaryDir, Base().ProjectSourceDir,
|
|
Base().ProjectBinaryDir);
|
|
|
|
// Moc variables
|
|
if (Moc().Enabled) {
|
|
// Mocs compilation file
|
|
Moc_.CompFileAbs = Base().AbsoluteBuildPath("mocs_compilation.cpp");
|
|
|
|
// Moc predefs file
|
|
if (!Moc_.PredefsCmd.empty()) {
|
|
Moc_.PredefsFileRel = "moc_predefs";
|
|
if (Base_.MultiConfig) {
|
|
Moc_.PredefsFileRel += '_';
|
|
Moc_.PredefsFileRel += InfoConfig();
|
|
}
|
|
Moc_.PredefsFileRel += ".h";
|
|
Moc_.PredefsFileAbs = Base_.AbsoluteBuildPath(Moc().PredefsFileRel);
|
|
}
|
|
|
|
// Sort include directories on demand
|
|
if (Base().IncludeProjectDirsBefore) {
|
|
// Move strings to temporary list
|
|
std::list<std::string> includes;
|
|
includes.insert(includes.end(), Moc().IncludePaths.begin(),
|
|
Moc().IncludePaths.end());
|
|
Moc_.IncludePaths.clear();
|
|
Moc_.IncludePaths.reserve(includes.size());
|
|
// Append project directories only
|
|
{
|
|
std::array<std::string const*, 2> const movePaths = {
|
|
{ &Base().ProjectBinaryDir, &Base().ProjectSourceDir }
|
|
};
|
|
for (std::string const* ppath : movePaths) {
|
|
std::list<std::string>::iterator it = includes.begin();
|
|
while (it != includes.end()) {
|
|
std::string const& path = *it;
|
|
if (cmSystemTools::StringStartsWith(path, ppath->c_str())) {
|
|
Moc_.IncludePaths.push_back(path);
|
|
it = includes.erase(it);
|
|
} else {
|
|
++it;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Append remaining directories
|
|
Moc_.IncludePaths.insert(Moc_.IncludePaths.end(), includes.begin(),
|
|
includes.end());
|
|
}
|
|
// Compose moc includes list
|
|
{
|
|
std::set<std::string> frameworkPaths;
|
|
for (std::string const& path : Moc().IncludePaths) {
|
|
Moc_.Includes.push_back("-I" + path);
|
|
// Extract framework path
|
|
if (cmHasLiteralSuffix(path, ".framework/Headers")) {
|
|
// Go up twice to get to the framework root
|
|
std::vector<std::string> pathComponents;
|
|
FileSys().SplitPath(path, pathComponents);
|
|
std::string frameworkPath = FileSys().JoinPath(
|
|
pathComponents.begin(), pathComponents.end() - 2);
|
|
frameworkPaths.insert(frameworkPath);
|
|
}
|
|
}
|
|
// Append framework includes
|
|
for (std::string const& path : frameworkPaths) {
|
|
Moc_.Includes.emplace_back("-F");
|
|
Moc_.Includes.push_back(path);
|
|
}
|
|
}
|
|
// Setup single list with all options
|
|
{
|
|
// Add includes
|
|
Moc_.AllOptions.insert(Moc_.AllOptions.end(), Moc().Includes.begin(),
|
|
Moc().Includes.end());
|
|
// Add definitions
|
|
for (std::string const& def : Moc().Definitions) {
|
|
Moc_.AllOptions.push_back("-D" + def);
|
|
}
|
|
// Add options
|
|
Moc_.AllOptions.insert(Moc_.AllOptions.end(), Moc().Options.begin(),
|
|
Moc().Options.end());
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool cmQtAutoMocUic::Process()
|
|
{
|
|
SettingsFileRead();
|
|
if (!CreateDirectories()) {
|
|
return false;
|
|
}
|
|
if (!WorkerPool_.Process(this)) {
|
|
return false;
|
|
}
|
|
if (JobError_) {
|
|
return false;
|
|
}
|
|
return SettingsFileWrite();
|
|
}
|
|
|
|
void cmQtAutoMocUic::SettingsFileRead()
|
|
{
|
|
// Compose current settings strings
|
|
{
|
|
cmCryptoHash crypt(cmCryptoHash::AlgoSHA256);
|
|
std::string const sep(" ~~~ ");
|
|
if (Moc_.Enabled) {
|
|
std::string str;
|
|
str += Moc().Executable;
|
|
str += sep;
|
|
str += cmJoin(Moc().AllOptions, ";");
|
|
str += sep;
|
|
str += Base().IncludeProjectDirsBefore ? "TRUE" : "FALSE";
|
|
str += sep;
|
|
str += cmJoin(Moc().PredefsCmd, ";");
|
|
str += sep;
|
|
SettingsStringMoc_ = crypt.HashString(str);
|
|
}
|
|
if (Uic().Enabled) {
|
|
std::string str;
|
|
str += Uic().Executable;
|
|
str += sep;
|
|
str += cmJoin(Uic().TargetOptions, ";");
|
|
for (const auto& item : Uic().Options) {
|
|
str += sep;
|
|
str += item.first;
|
|
str += sep;
|
|
str += cmJoin(item.second, ";");
|
|
}
|
|
str += sep;
|
|
SettingsStringUic_ = crypt.HashString(str);
|
|
}
|
|
}
|
|
|
|
// Read old settings and compare
|
|
{
|
|
std::string content;
|
|
if (FileSys().FileRead(content, SettingsFile_)) {
|
|
if (Moc().Enabled) {
|
|
if (SettingsStringMoc_ != SettingsFind(content, "moc")) {
|
|
Moc_.SettingsChanged = true;
|
|
}
|
|
}
|
|
if (Uic().Enabled) {
|
|
if (SettingsStringUic_ != SettingsFind(content, "uic")) {
|
|
Uic_.SettingsChanged = true;
|
|
}
|
|
}
|
|
// In case any setting changed remove the old settings file.
|
|
// This triggers a full rebuild on the next run if the current
|
|
// build is aborted before writing the current settings in the end.
|
|
if (Moc().SettingsChanged || Uic().SettingsChanged) {
|
|
FileSys().FileRemove(SettingsFile_);
|
|
}
|
|
} else {
|
|
// Settings file read failed
|
|
if (Moc().Enabled) {
|
|
Moc_.SettingsChanged = true;
|
|
}
|
|
if (Uic().Enabled) {
|
|
Uic_.SettingsChanged = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool cmQtAutoMocUic::SettingsFileWrite()
|
|
{
|
|
// Only write if any setting changed
|
|
if (Moc().SettingsChanged || Uic().SettingsChanged) {
|
|
if (Log().Verbose()) {
|
|
Log().Info(GenT::GEN, "Writing settings file " + Quoted(SettingsFile_));
|
|
}
|
|
// Compose settings file content
|
|
std::string content;
|
|
{
|
|
auto SettingAppend = [&content](const char* key,
|
|
std::string const& value) {
|
|
if (!value.empty()) {
|
|
content += key;
|
|
content += ':';
|
|
content += value;
|
|
content += '\n';
|
|
}
|
|
};
|
|
SettingAppend("moc", SettingsStringMoc_);
|
|
SettingAppend("uic", SettingsStringUic_);
|
|
}
|
|
// Write settings file
|
|
std::string error;
|
|
if (!FileSys().FileWrite(SettingsFile_, content, &error)) {
|
|
Log().ErrorFile(GenT::GEN, SettingsFile_,
|
|
"Settings file writing failed. " + error);
|
|
// Remove old settings file to trigger a full rebuild on the next run
|
|
FileSys().FileRemove(SettingsFile_);
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool cmQtAutoMocUic::CreateDirectories()
|
|
{
|
|
// Create AUTOGEN include directory
|
|
if (!FileSys().MakeDirectory(Base().AutogenIncludeDir)) {
|
|
Log().ErrorFile(GenT::GEN, Base().AutogenIncludeDir,
|
|
"Could not create directory.");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Private method that requires cmQtAutoMocUic::JobsMutex_ to be
|
|
// locked
|
|
void cmQtAutoMocUic::Abort(bool error)
|
|
{
|
|
if (error) {
|
|
JobError_.store(true);
|
|
}
|
|
WorkerPool_.Abort();
|
|
}
|
|
|
|
bool cmQtAutoMocUic::ParallelJobPushMoc(cmWorkerPool::JobHandleT&& jobHandle)
|
|
{
|
|
JobMocT const& mocJob(static_cast<JobMocT&>(*jobHandle));
|
|
// Do additional tests if this is an included moc job
|
|
if (!mocJob.IncludeString.empty()) {
|
|
std::lock_guard<std::mutex> guard(MocMetaMutex_);
|
|
// Register included moc file
|
|
MocIncludedFiles_.emplace(mocJob.SourceFile);
|
|
|
|
// Check if the same moc file would be generated from a different
|
|
// source file.
|
|
auto const range = MocIncludes_.equal_range(mocJob.IncludeString);
|
|
for (auto it = range.first; it != range.second; ++it) {
|
|
if (it->second[0] == mocJob.SourceFile) {
|
|
// The output file already gets generated
|
|
return true;
|
|
}
|
|
{
|
|
// The output file already gets generated - from a different source
|
|
// file!
|
|
std::string error = "The two source files\n ";
|
|
error += Quoted(mocJob.IncluderFile);
|
|
error += " and\n ";
|
|
error += Quoted(it->second[1]);
|
|
error += "\ncontain the same moc include string ";
|
|
error += Quoted(mocJob.IncludeString);
|
|
error += "\nbut the moc file would be generated from different "
|
|
"source files\n ";
|
|
error += Quoted(mocJob.SourceFile);
|
|
error += " and\n ";
|
|
error += Quoted(it->second[0]);
|
|
error += ".\nConsider to\n"
|
|
"- not include the \"moc_<NAME>.cpp\" file\n"
|
|
"- add a directory prefix to a \"<NAME>.moc\" include "
|
|
"(e.g \"sub/<NAME>.moc\")\n"
|
|
"- rename the source file(s)\n";
|
|
Log().Error(GenT::MOC, error);
|
|
AbortError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// We're still here so register this job
|
|
MocIncludes_.emplace_hint(range.first, mocJob.IncludeString,
|
|
std::array<std::string, 2>{
|
|
{ mocJob.SourceFile, mocJob.IncluderFile } });
|
|
}
|
|
return WorkerPool_.PushJob(std::move(jobHandle));
|
|
}
|
|
|
|
bool cmQtAutoMocUic::ParallelJobPushUic(cmWorkerPool::JobHandleT&& jobHandle)
|
|
{
|
|
const JobUicT& uicJob(static_cast<JobUicT&>(*jobHandle));
|
|
{
|
|
std::lock_guard<std::mutex> guard(UicMetaMutex_);
|
|
// Check if the same uic file would be generated from a different
|
|
// source file.
|
|
auto const range = UicIncludes_.equal_range(uicJob.IncludeString);
|
|
for (auto it = range.first; it != range.second; ++it) {
|
|
if (it->second[0] == uicJob.SourceFile) {
|
|
// The output file already gets generated
|
|
return true;
|
|
}
|
|
{
|
|
// The output file already gets generated - from a different .ui
|
|
// file!
|
|
std::string error = "The two source files\n ";
|
|
error += Quoted(uicJob.IncluderFile);
|
|
error += " and\n ";
|
|
error += Quoted(it->second[1]);
|
|
error += "\ncontain the same uic include string ";
|
|
error += Quoted(uicJob.IncludeString);
|
|
error += "\nbut the uic file would be generated from different "
|
|
"source files\n ";
|
|
error += Quoted(uicJob.SourceFile);
|
|
error += " and\n ";
|
|
error += Quoted(it->second[0]);
|
|
error +=
|
|
".\nConsider to\n"
|
|
"- add a directory prefix to a \"ui_<NAME>.h\" include "
|
|
"(e.g \"sub/ui_<NAME>.h\")\n"
|
|
"- rename the <NAME>.ui file(s) and adjust the \"ui_<NAME>.h\" "
|
|
"include(s)\n";
|
|
Log().Error(GenT::UIC, error);
|
|
AbortError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// We're still here so register this job
|
|
UicIncludes_.emplace_hint(range.first, uicJob.IncludeString,
|
|
std::array<std::string, 2>{
|
|
{ uicJob.SourceFile, uicJob.IncluderFile } });
|
|
}
|
|
return WorkerPool_.PushJob(std::move(jobHandle));
|
|
}
|
|
|
|
bool cmQtAutoMocUic::ParallelMocIncluded(std::string const& sourceFile)
|
|
{
|
|
std::lock_guard<std::mutex> guard(MocMetaMutex_);
|
|
return (MocIncludedFiles_.find(sourceFile) != MocIncludedFiles_.end());
|
|
}
|
|
|
|
std::string cmQtAutoMocUic::ParallelMocAutoRegister(
|
|
std::string const& baseName)
|
|
{
|
|
std::string res;
|
|
{
|
|
std::lock_guard<std::mutex> mocLock(MocMetaMutex_);
|
|
res = baseName;
|
|
res += ".cpp";
|
|
if (MocAutoFiles_.find(res) == MocAutoFiles_.end()) {
|
|
MocAutoFiles_.emplace(res);
|
|
} else {
|
|
// Append number suffix to the file name
|
|
for (unsigned int ii = 2; ii != 1024; ++ii) {
|
|
res = baseName;
|
|
res += '_';
|
|
res += std::to_string(ii);
|
|
res += ".cpp";
|
|
if (MocAutoFiles_.find(res) == MocAutoFiles_.end()) {
|
|
MocAutoFiles_.emplace(res);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return res;
|
|
}
|