summaryrefslogtreecommitdiffstats
path: root/Source/cmQtAutoGeneratorInitializer.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'Source/cmQtAutoGeneratorInitializer.cxx')
-rw-r--r--Source/cmQtAutoGeneratorInitializer.cxx850
1 files changed, 449 insertions, 401 deletions
diff --git a/Source/cmQtAutoGeneratorInitializer.cxx b/Source/cmQtAutoGeneratorInitializer.cxx
index cecf165..07fb528 100644
--- a/Source/cmQtAutoGeneratorInitializer.cxx
+++ b/Source/cmQtAutoGeneratorInitializer.cxx
@@ -4,6 +4,7 @@
#include "cmQtAutoGeneratorCommon.h"
#include "cmAlgorithms.h"
+#include "cmCustomCommand.h"
#include "cmCustomCommandLines.h"
#include "cmFilePathChecksum.h"
#include "cmGeneratorTarget.h"
@@ -11,6 +12,7 @@
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
#include "cmOutputConverter.h"
+#include "cmPolicies.h"
#include "cmSourceFile.h"
#include "cmSourceGroup.h"
#include "cmState.h"
@@ -18,40 +20,30 @@
#include "cmTarget.h"
#include "cm_sys_stat.h"
#include "cmake.h"
-
-#if defined(_WIN32) && !defined(__CYGWIN__)
-#include "cmGlobalVisualStudioGenerator.h"
-#endif
-
-#include "cmConfigure.h"
#include "cmsys/FStream.hxx"
+
#include <algorithm>
#include <map>
#include <set>
+#include <sstream>
#include <string>
#include <utility>
#include <vector>
-static void utilCopyTargetProperty(cmTarget* destinationTarget,
- cmTarget* sourceTarget,
- const std::string& propertyName)
+inline static const char* SafeString(const char* value)
{
- const char* propertyValue = sourceTarget->GetProperty(propertyName);
- if (propertyValue) {
- destinationTarget->SetProperty(propertyName, propertyValue);
- }
+ return (value != nullptr) ? value : "";
}
-inline static bool PropertyEnabled(cmSourceFile* sourceFile, const char* key)
+static std::string GetSafeProperty(cmGeneratorTarget const* target,
+ const char* key)
{
- return cmSystemTools::IsOn(sourceFile->GetPropertyForUser(key));
+ return std::string(SafeString(target->GetProperty(key)));
}
-static std::string GetSafeProperty(cmGeneratorTarget const* target,
- const char* key)
+inline static bool AutogenMultiConfig(cmGlobalGenerator* globalGen)
{
- const char* tmp = target->GetProperty(key);
- return std::string((tmp != CM_NULLPTR) ? tmp : "");
+ return globalGen->IsMultiConfig();
}
static std::string GetAutogenTargetName(cmGeneratorTarget const* target)
@@ -93,7 +85,7 @@ static std::string GetQtMajorVersion(cmGeneratorTarget const* target)
}
const char* targetQtVersion =
target->GetLinkInterfaceDependentStringProperty("QT_MAJOR_VERSION", "");
- if (targetQtVersion != CM_NULLPTR) {
+ if (targetQtVersion != nullptr) {
qtMajorVersion = targetQtVersion;
}
return qtMajorVersion;
@@ -113,7 +105,7 @@ static std::string GetQtMinorVersion(cmGeneratorTarget const* target,
const char* targetQtVersion =
target->GetLinkInterfaceDependentStringProperty("QT_MINOR_VERSION", "");
- if (targetQtVersion != CM_NULLPTR) {
+ if (targetQtVersion != nullptr) {
qtMinorVersion = targetQtVersion;
}
return qtMinorVersion;
@@ -154,28 +146,13 @@ static void GetCompileDefinitionsAndDirectories(
}
}
-static bool IsMultiConfig(cmGlobalGenerator* globalGen)
-{
- // FIXME: Xcode does not support per-config sources, yet.
- // (EXCLUDED_SOURCE_FILE_NAMES)
- // Treat it as a single configuration generator meanwhile.
- if (globalGen->GetName().find("Xcode") != std::string::npos) {
- return false;
- }
- // FIXME: Visual Studio does not fully support per-config sources yet.
- if (globalGen->GetName().find("Visual Studio") != std::string::npos) {
- return false;
- }
- return globalGen->IsMultiConfig();
-}
-
static std::vector<std::string> GetConfigurations(
- cmMakefile* makefile, std::string* config = CM_NULLPTR)
+ cmMakefile* makefile, std::string* config = nullptr)
{
std::vector<std::string> configs;
{
std::string cfg = makefile->GetConfigurations(configs);
- if (config != CM_NULLPTR) {
+ if (config != nullptr) {
*config = cfg;
}
}
@@ -189,7 +166,7 @@ static std::vector<std::string> GetConfigurations(
static std::vector<std::string> GetConfigurationSuffixes(cmMakefile* makefile)
{
std::vector<std::string> suffixes;
- if (IsMultiConfig(makefile->GetGlobalGenerator())) {
+ if (AutogenMultiConfig(makefile->GetGlobalGenerator())) {
makefile->GetConfigurations(suffixes);
for (std::vector<std::string>::iterator it = suffixes.begin();
it != suffixes.end(); ++it) {
@@ -216,13 +193,20 @@ static void AddDefinitionEscaped(cmMakefile* makefile, const char* key,
key, cmOutputConverter::EscapeForCMake(cmJoin(values, ";")).c_str());
}
+static void AddDefinitionEscaped(cmMakefile* makefile, const char* key,
+ const std::set<std::string>& values)
+{
+ makefile->AddDefinition(
+ key, cmOutputConverter::EscapeForCMake(cmJoin(values, ";")).c_str());
+}
+
static bool AddToSourceGroup(cmMakefile* makefile, const std::string& fileName,
cmQtAutoGeneratorCommon::GeneratorType genType)
{
- cmSourceGroup* sourceGroup = CM_NULLPTR;
+ cmSourceGroup* sourceGroup = nullptr;
// Acquire source group
{
- const char* groupName = CM_NULLPTR;
+ const char* groupName = nullptr;
// Use generator specific group name
switch (genType) {
case cmQtAutoGeneratorCommon::MOC:
@@ -237,27 +221,27 @@ static bool AddToSourceGroup(cmMakefile* makefile, const std::string& fileName,
break;
}
// Use default group name on demand
- if ((groupName == CM_NULLPTR) || (*groupName == 0)) {
+ if ((groupName == nullptr) || (*groupName == 0)) {
groupName =
makefile->GetState()->GetGlobalProperty("AUTOGEN_SOURCE_GROUP");
}
// Generate a source group on demand
- if ((groupName != CM_NULLPTR) && (*groupName != 0)) {
+ if ((groupName != nullptr) && (*groupName != 0)) {
{
const char* delimiter =
makefile->GetDefinition("SOURCE_GROUP_DELIMITER");
- if (delimiter == CM_NULLPTR) {
+ if (delimiter == nullptr) {
delimiter = "\\";
}
std::vector<std::string> folders =
cmSystemTools::tokenize(groupName, delimiter);
sourceGroup = makefile->GetSourceGroup(folders);
- if (sourceGroup == CM_NULLPTR) {
+ if (sourceGroup == nullptr) {
makefile->AddSourceGroup(folders);
sourceGroup = makefile->GetSourceGroup(folders);
}
}
- if (sourceGroup == CM_NULLPTR) {
+ if (sourceGroup == nullptr) {
cmSystemTools::Error(
"Autogen: Could not create or find source group: ",
cmQtAutoGeneratorCommon::Quoted(groupName).c_str());
@@ -265,101 +249,164 @@ static bool AddToSourceGroup(cmMakefile* makefile, const std::string& fileName,
}
}
}
- if (sourceGroup != CM_NULLPTR) {
+ if (sourceGroup != nullptr) {
sourceGroup->AddGroupFile(fileName);
}
return true;
}
-static void AddGeneratedSource(cmMakefile* makefile,
+static void AddCleanFile(cmMakefile* makefile, const std::string& fileName)
+{
+ makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES", fileName.c_str(),
+ false);
+}
+
+static void AddGeneratedSource(cmGeneratorTarget* target,
const std::string& filename,
cmQtAutoGeneratorCommon::GeneratorType genType)
{
- cmSourceFile* gFile = makefile->GetOrCreateSource(filename, true);
- gFile->SetProperty("GENERATED", "1");
- gFile->SetProperty("SKIP_AUTOGEN", "On");
+ cmMakefile* makefile = target->Target->GetMakefile();
+ {
+ cmSourceFile* gFile = makefile->GetOrCreateSource(filename, true);
+ gFile->SetProperty("GENERATED", "1");
+ gFile->SetProperty("SKIP_AUTOGEN", "On");
+ }
+ target->AddSource(filename);
AddToSourceGroup(makefile, filename, genType);
}
-static void AcquireScanFiles(cmGeneratorTarget const* target,
- std::vector<std::string>& mocUicSources,
- std::vector<std::string>& mocUicHeaders,
- std::vector<std::string>& mocSkipList,
- std::vector<std::string>& uicSkipList)
+struct AutogenSetup
{
- const bool mocTarget = target->GetPropertyAsBool("AUTOMOC");
- const bool uicTarget = target->GetPropertyAsBool("AUTOUIC");
+ std::vector<std::string> sources;
+ std::vector<std::string> headers;
- std::vector<cmSourceFile*> srcFiles;
- target->GetConfigCommonSourceFiles(srcFiles);
+ std::set<std::string> mocSkip;
+ std::set<std::string> uicSkip;
+
+ std::map<std::string, std::string> configSuffix;
+ std::map<std::string, std::string> configMocIncludes;
+ std::map<std::string, std::string> configMocDefines;
+ std::map<std::string, std::string> configUicOptions;
+};
+
+static void SetupAcquireScanFiles(cmGeneratorTarget const* target,
+ bool mocEnabled, bool uicEnabled,
+ const std::vector<cmSourceFile*>& srcFiles,
+ AutogenSetup& setup)
+{
+ // Read skip files from makefile sources
+ {
+ const std::vector<cmSourceFile*>& allSources =
+ target->Makefile->GetSourceFiles();
+ for (std::vector<cmSourceFile*>::const_iterator fit = allSources.begin();
+ fit != allSources.end(); ++fit) {
+ cmSourceFile* sf = *fit;
+ // sf->GetExtension() is only valid after sf->GetFullPath() ...
+ const std::string& fPath = sf->GetFullPath();
+ const cmSystemTools::FileFormat fileType =
+ cmSystemTools::GetFileFormat(sf->GetExtension().c_str());
+ if (!(fileType == cmSystemTools::CXX_FILE_FORMAT) &&
+ !(fileType == cmSystemTools::HEADER_FILE_FORMAT)) {
+ continue;
+ }
+ const bool skipAll = sf->GetPropertyAsBool("SKIP_AUTOGEN");
+ const bool mocSkip =
+ mocEnabled && (skipAll || sf->GetPropertyAsBool("SKIP_AUTOMOC"));
+ const bool uicSkip =
+ uicEnabled && (skipAll || sf->GetPropertyAsBool("SKIP_AUTOUIC"));
+ if (mocSkip || uicSkip) {
+ const std::string absFile = cmsys::SystemTools::GetRealPath(fPath);
+ if (mocSkip) {
+ setup.mocSkip.insert(absFile);
+ }
+ if (uicSkip) {
+ setup.uicSkip.insert(absFile);
+ }
+ }
+ }
+ }
+
+ const cmPolicies::PolicyStatus CMP0071_status =
+ target->Makefile->GetPolicyStatus(cmPolicies::CMP0071);
for (std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
fileIt != srcFiles.end(); ++fileIt) {
cmSourceFile* sf = *fileIt;
+ // sf->GetExtension() is only valid after sf->GetFullPath() ...
+ const std::string& fPath = sf->GetFullPath();
const cmSystemTools::FileFormat fileType =
cmSystemTools::GetFileFormat(sf->GetExtension().c_str());
-
if (!(fileType == cmSystemTools::CXX_FILE_FORMAT) &&
!(fileType == cmSystemTools::HEADER_FILE_FORMAT)) {
continue;
}
- if (PropertyEnabled(sf, "GENERATED") &&
- !target->GetPropertyAsBool("__UNDOCUMENTED_AUTOGEN_GENERATED_FILES")) {
- // FIXME: Add a policy whose NEW behavior allows generated files.
- // The implementation already works. We disable it here to avoid
- // changing behavior for existing projects that do not expect it.
+ // Real file path
+ const std::string absFile = cmsys::SystemTools::GetRealPath(fPath);
+ // Skip test
+ const bool mocSkip = !mocEnabled || (setup.mocSkip.count(absFile) != 0);
+ const bool uicSkip = !uicEnabled || (setup.uicSkip.count(absFile) != 0);
+ if (mocSkip && uicSkip) {
continue;
}
- const std::string absFile =
- cmsys::SystemTools::GetRealPath(sf->GetFullPath());
- // Skip flags
- const bool skipAll = PropertyEnabled(sf, "SKIP_AUTOGEN");
- const bool mocSkip = skipAll || PropertyEnabled(sf, "SKIP_AUTOMOC");
- const bool uicSkip = skipAll || PropertyEnabled(sf, "SKIP_AUTOUIC");
- // Add file name to skip lists.
- // Do this even when the file is not added to the sources/headers lists
- // because the file name may be extracted from an other file when
- // processing
- if (mocSkip) {
- mocSkipList.push_back(absFile);
- }
- if (uicSkip) {
- uicSkipList.push_back(absFile);
- }
- if ((mocTarget && !mocSkip) || (uicTarget && !uicSkip)) {
- // Add file name to sources or headers list
- switch (fileType) {
- case cmSystemTools::CXX_FILE_FORMAT:
- mocUicSources.push_back(absFile);
- break;
- case cmSystemTools::HEADER_FILE_FORMAT:
- mocUicHeaders.push_back(absFile);
+ // For GENERATED files check status of policy CMP0071
+ if (sf->GetPropertyAsBool("GENERATED")) {
+ bool policyAccept = false;
+ switch (CMP0071_status) {
+ case cmPolicies::WARN: {
+ std::ostringstream ost;
+ ost << cmPolicies::GetPolicyWarning(cmPolicies::CMP0071) << "\n";
+ ost << "AUTOMOC/AUTOUIC: Ignoring GENERATED source file:\n";
+ ost << " " << cmQtAutoGeneratorCommon::Quoted(absFile) << "\n";
+ target->Makefile->IssueMessage(cmake::AUTHOR_WARNING, ost.str());
+ }
+ CM_FALLTHROUGH;
+ case cmPolicies::OLD:
+ // Ignore GENERATED file
break;
- default:
+ case cmPolicies::REQUIRED_IF_USED:
+ case cmPolicies::REQUIRED_ALWAYS:
+ case cmPolicies::NEW:
+ // Process GENERATED file
+ policyAccept = true;
break;
}
+ if (!policyAccept) {
+ continue;
+ }
+ }
+
+ // Add file name to sources or headers list
+ switch (fileType) {
+ case cmSystemTools::CXX_FILE_FORMAT:
+ setup.sources.push_back(absFile);
+ break;
+ case cmSystemTools::HEADER_FILE_FORMAT:
+ setup.headers.push_back(absFile);
+ break;
+ default:
+ break;
}
}
}
-static void MocSetupAutoTarget(
- cmGeneratorTarget const* target, const std::string& autogenTargetName,
- std::string const& qtMajorVersion, std::string const& config,
- std::vector<std::string> const& configs,
- std::vector<std::string> const& mocSkipList,
- std::map<std::string, std::string>& configMocIncludes,
- std::map<std::string, std::string>& configMocDefines)
+static void SetupAutoTargetMoc(cmGeneratorTarget const* target,
+ std::string const& qtMajorVersion,
+ std::string const& config,
+ std::vector<std::string> const& configs,
+ AutogenSetup& setup)
{
- cmLocalGenerator* lg = target->GetLocalGenerator();
+ cmLocalGenerator* localGen = target->GetLocalGenerator();
cmMakefile* makefile = target->Target->GetMakefile();
+ AddDefinitionEscaped(makefile, "_moc_skip", setup.mocSkip);
AddDefinitionEscaped(makefile, "_moc_options",
GetSafeProperty(target, "AUTOMOC_MOC_OPTIONS"));
- AddDefinitionEscaped(makefile, "_moc_skip", mocSkipList);
AddDefinitionEscaped(makefile, "_moc_relaxed_mode",
makefile->IsOn("CMAKE_AUTOMOC_RELAXED_MODE") ? "TRUE"
: "FALSE");
+ AddDefinitionEscaped(makefile, "_moc_macro_names",
+ GetSafeProperty(target, "AUTOMOC_MACRO_NAMES"));
AddDefinitionEscaped(makefile, "_moc_depend_filters",
GetSafeProperty(target, "AUTOMOC_DEPEND_FILTERS"));
@@ -386,42 +433,41 @@ static void MocSetupAutoTarget(
GetCompileDefinitionsAndDirectories(target, *li, configIncs,
configCompileDefs);
if (configIncs != incs) {
- configMocIncludes[*li] = cmOutputConverter::EscapeForCMake(configIncs);
+ setup.configMocIncludes[*li] = configIncs;
}
if (configCompileDefs != compileDefs) {
- configMocDefines[*li] =
- cmOutputConverter::EscapeForCMake(configCompileDefs);
+ setup.configMocDefines[*li] = configCompileDefs;
}
}
}
// Moc executable
{
+ std::string mocExec;
std::string err;
- const char* mocExec = CM_NULLPTR;
+
if (qtMajorVersion == "5") {
- cmGeneratorTarget* qt5Moc = lg->FindGeneratorTargetToUse("Qt5::moc");
- if (qt5Moc != CM_NULLPTR) {
- mocExec = qt5Moc->ImportedGetLocation("");
+ cmGeneratorTarget* tgt = localGen->FindGeneratorTargetToUse("Qt5::moc");
+ if (tgt != nullptr) {
+ mocExec = SafeString(tgt->ImportedGetLocation(""));
} else {
- err = "Qt5::moc target not found " + autogenTargetName;
+ err = "AUTOMOC: Qt5::moc target not found";
}
} else if (qtMajorVersion == "4") {
- cmGeneratorTarget* qt4Moc = lg->FindGeneratorTargetToUse("Qt4::moc");
- if (qt4Moc != CM_NULLPTR) {
- mocExec = qt4Moc->ImportedGetLocation("");
+ cmGeneratorTarget* tgt = localGen->FindGeneratorTargetToUse("Qt4::moc");
+ if (tgt != nullptr) {
+ mocExec = SafeString(tgt->ImportedGetLocation(""));
} else {
- err = "Qt4::moc target not found " + autogenTargetName;
+ err = "AUTOMOC: Qt4::moc target not found";
}
} else {
- err = "The CMAKE_AUTOMOC feature supports only Qt 4 and Qt 5 ";
- err += autogenTargetName;
+ err = "The AUTOMOC feature supports only Qt 4 and Qt 5";
}
- // Add definition or error
+
if (err.empty()) {
- AddDefinitionEscaped(makefile, "_qt_moc_executable",
- mocExec ? mocExec : "");
+ AddDefinitionEscaped(makefile, "_qt_moc_executable", mocExec);
} else {
+ err += " (" + target->GetName() + ")";
cmSystemTools::Error(err.c_str());
}
}
@@ -435,26 +481,30 @@ static void UicGetOpts(cmGeneratorTarget const* target,
optString = cmJoin(opts, ";");
}
-static void UicSetupAutoTarget(
- cmGeneratorTarget const* target, std::string const& qtMajorVersion,
- std::string const& config, std::vector<std::string> const& configs,
- std::vector<std::string> const& uicSkipList,
- std::map<std::string, std::string>& configUicOptions)
+static void SetupAutoTargetUic(cmGeneratorTarget const* target,
+ std::string const& qtMajorVersion,
+ std::string const& config,
+ std::vector<std::string> const& configs,
+ AutogenSetup& setup)
{
- cmLocalGenerator* lg = target->GetLocalGenerator();
+ cmLocalGenerator* localGen = target->GetLocalGenerator();
cmMakefile* makefile = target->Target->GetMakefile();
- AddDefinitionEscaped(makefile, "_uic_skip", uicSkipList);
+ AddDefinitionEscaped(makefile, "_uic_skip", setup.uicSkip);
// Uic search paths
{
std::vector<std::string> uicSearchPaths;
- cmSystemTools::ExpandListArgument(
- GetSafeProperty(target, "AUTOUIC_SEARCH_PATHS"), uicSearchPaths);
- const std::string srcDir = makefile->GetCurrentSourceDirectory();
- for (std::vector<std::string>::iterator it = uicSearchPaths.begin();
- it != uicSearchPaths.end(); ++it) {
- *it = cmSystemTools::CollapseFullPath(*it, srcDir);
+ {
+ const std::string usp = GetSafeProperty(target, "AUTOUIC_SEARCH_PATHS");
+ if (!usp.empty()) {
+ cmSystemTools::ExpandListArgument(usp, uicSearchPaths);
+ const std::string srcDir = makefile->GetCurrentSourceDirectory();
+ for (std::vector<std::string>::iterator it = uicSearchPaths.begin();
+ it != uicSearchPaths.end(); ++it) {
+ *it = cmSystemTools::CollapseFullPath(*it, srcDir);
+ }
+ }
}
AddDefinitionEscaped(makefile, "_uic_search_paths", uicSearchPaths);
}
@@ -471,8 +521,7 @@ static void UicSetupAutoTarget(
std::string configUicOpts;
UicGetOpts(target, *li, configUicOpts);
if (configUicOpts != uicOpts) {
- configUicOptions[*li] =
- cmOutputConverter::EscapeForCMake(configUicOpts);
+ setup.configUicOptions[*li] = configUicOpts;
}
}
}
@@ -481,25 +530,25 @@ static void UicSetupAutoTarget(
std::vector<std::string> uiFileFiles;
std::vector<std::string> uiFileOptions;
{
- std::set<std::string> skipped;
- skipped.insert(uicSkipList.begin(), uicSkipList.end());
-
- const std::vector<cmSourceFile*> uiFilesWithOptions =
- makefile->GetQtUiFilesWithOptions();
- for (std::vector<cmSourceFile*>::const_iterator fileIt =
- uiFilesWithOptions.begin();
- fileIt != uiFilesWithOptions.end(); ++fileIt) {
- cmSourceFile* sf = *fileIt;
- const std::string absFile =
- cmsys::SystemTools::GetRealPath(sf->GetFullPath());
- if (skipped.insert(absFile).second) {
- // The file wasn't skipped
- uiFileFiles.push_back(absFile);
- {
- std::string opts = sf->GetProperty("AUTOUIC_OPTIONS");
- cmSystemTools::ReplaceString(opts, ";",
- cmQtAutoGeneratorCommon::listSep);
- uiFileOptions.push_back(opts);
+ const std::string uiExt = "ui";
+ const std::vector<cmSourceFile*>& srcFiles = makefile->GetSourceFiles();
+ for (std::vector<cmSourceFile*>::const_iterator fit = srcFiles.begin();
+ fit != srcFiles.end(); ++fit) {
+ cmSourceFile* sf = *fit;
+ // sf->GetExtension() is only valid after sf->GetFullPath() ...
+ const std::string& fPath = sf->GetFullPath();
+ if (sf->GetExtension() == uiExt) {
+ // Check if the files has uic options
+ std::string uicOpts = sf->GetProperty("AUTOUIC_OPTIONS");
+ if (!uicOpts.empty()) {
+ const std::string absFile = cmsys::SystemTools::GetRealPath(fPath);
+ // Check if file isn't skipped
+ if (setup.uicSkip.count(absFile) == 0) {
+ uiFileFiles.push_back(absFile);
+ cmSystemTools::ReplaceString(uicOpts, ";",
+ cmQtAutoGeneratorCommon::listSep);
+ uiFileOptions.push_back(uicOpts);
+ }
}
}
}
@@ -511,30 +560,30 @@ static void UicSetupAutoTarget(
// Uic executable
{
std::string err;
- const char* uicExec = CM_NULLPTR;
+ std::string uicExec;
+
if (qtMajorVersion == "5") {
- cmGeneratorTarget* qt5Uic = lg->FindGeneratorTargetToUse("Qt5::uic");
- if (qt5Uic != CM_NULLPTR) {
- uicExec = qt5Uic->ImportedGetLocation("");
+ cmGeneratorTarget* tgt = localGen->FindGeneratorTargetToUse("Qt5::uic");
+ if (tgt != nullptr) {
+ uicExec = SafeString(tgt->ImportedGetLocation(""));
} else {
// Project does not use Qt5Widgets, but has AUTOUIC ON anyway
}
} else if (qtMajorVersion == "4") {
- cmGeneratorTarget* qt4Uic = lg->FindGeneratorTargetToUse("Qt4::uic");
- if (qt4Uic != CM_NULLPTR) {
- uicExec = qt4Uic->ImportedGetLocation("");
+ cmGeneratorTarget* tgt = localGen->FindGeneratorTargetToUse("Qt4::uic");
+ if (tgt != nullptr) {
+ uicExec = SafeString(tgt->ImportedGetLocation(""));
} else {
- err = "Qt4::uic target not found " + target->GetName();
+ err = "AUTOUIC: Qt4::uic target not found";
}
} else {
- err = "The CMAKE_AUTOUIC feature supports only Qt 4 and Qt 5 ";
- err += target->GetName();
+ err = "The AUTOUIC feature supports only Qt 4 and Qt 5";
}
- // Add definition or error
+
if (err.empty()) {
- AddDefinitionEscaped(makefile, "_qt_uic_executable",
- uicExec ? uicExec : "");
+ AddDefinitionEscaped(makefile, "_qt_uic_executable", uicExec);
} else {
+ err += " (" + target->GetName() + ")";
cmSystemTools::Error(err.c_str());
}
}
@@ -544,27 +593,30 @@ static std::string RccGetExecutable(cmGeneratorTarget const* target,
const std::string& qtMajorVersion)
{
std::string rccExec;
- cmLocalGenerator* lg = target->GetLocalGenerator();
+ std::string err;
+
+ cmLocalGenerator* localGen = target->GetLocalGenerator();
if (qtMajorVersion == "5") {
- cmGeneratorTarget* qt5Rcc = lg->FindGeneratorTargetToUse("Qt5::rcc");
- if (qt5Rcc != CM_NULLPTR) {
- rccExec = qt5Rcc->ImportedGetLocation("");
+ cmGeneratorTarget* tgt = localGen->FindGeneratorTargetToUse("Qt5::rcc");
+ if (tgt != nullptr) {
+ rccExec = SafeString(tgt->ImportedGetLocation(""));
} else {
- cmSystemTools::Error("Qt5::rcc target not found ",
- target->GetName().c_str());
+ err = "AUTORCC: Qt5::rcc target not found";
}
} else if (qtMajorVersion == "4") {
- cmGeneratorTarget* qt4Rcc = lg->FindGeneratorTargetToUse("Qt4::rcc");
- if (qt4Rcc != CM_NULLPTR) {
- rccExec = qt4Rcc->ImportedGetLocation("");
+ cmGeneratorTarget* tgt = localGen->FindGeneratorTargetToUse("Qt4::rcc");
+ if (tgt != nullptr) {
+ rccExec = SafeString(tgt->ImportedGetLocation(""));
} else {
- cmSystemTools::Error("Qt4::rcc target not found ",
- target->GetName().c_str());
+ err = "AUTORCC: Qt4::rcc target not found";
}
} else {
- cmSystemTools::Error(
- "The CMAKE_AUTORCC feature supports only Qt 4 and Qt 5 ",
- target->GetName().c_str());
+ err = "The AUTORCC feature supports only Qt 4 and Qt 5";
+ }
+
+ if (!err.empty()) {
+ err += " (" + target->GetName() + ")";
+ cmSystemTools::Error(err.c_str());
}
return rccExec;
}
@@ -606,38 +658,38 @@ static void RccMergeOptions(std::vector<std::string>& opts,
opts.insert(opts.end(), extraOpts.begin(), extraOpts.end());
}
-static void RccSetupAutoTarget(cmGeneratorTarget const* target,
- const std::string& qtMajorVersion)
+static void SetupAutoTargetRcc(cmGeneratorTarget const* target,
+ const std::string& qtMajorVersion,
+ const std::vector<cmSourceFile*>& srcFiles)
{
cmMakefile* makefile = target->Target->GetMakefile();
const bool qtMajorVersion5 = (qtMajorVersion == "5");
const std::string rccCommand = RccGetExecutable(target, qtMajorVersion);
- std::vector<std::string> _rcc_files;
- std::vector<std::string> _rcc_inputs;
+ std::vector<std::string> rccFiles;
+ std::vector<std::string> rccInputs;
std::vector<std::string> rccFileFiles;
std::vector<std::string> rccFileOptions;
std::vector<std::string> rccOptionsTarget;
- if (const char* opts = target->GetProperty("AUTORCC_OPTIONS")) {
- cmSystemTools::ExpandListArgument(opts, rccOptionsTarget);
- }
- std::vector<cmSourceFile*> srcFiles;
- target->GetConfigCommonSourceFiles(srcFiles);
+ cmSystemTools::ExpandListArgument(GetSafeProperty(target, "AUTORCC_OPTIONS"),
+ rccOptionsTarget);
+
for (std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
fileIt != srcFiles.end(); ++fileIt) {
cmSourceFile* sf = *fileIt;
+ // sf->GetExtension() is only valid after sf->GetFullPath() ...
+ const std::string& fPath = sf->GetFullPath();
if ((sf->GetExtension() == "qrc") &&
- !PropertyEnabled(sf, "SKIP_AUTOGEN") &&
- !PropertyEnabled(sf, "SKIP_AUTORCC")) {
- const std::string absFile =
- cmsys::SystemTools::GetRealPath(sf->GetFullPath());
+ !sf->GetPropertyAsBool("SKIP_AUTOGEN") &&
+ !sf->GetPropertyAsBool("SKIP_AUTORCC")) {
+ const std::string absFile = cmsys::SystemTools::GetRealPath(fPath);
// qrc file
- _rcc_files.push_back(absFile);
+ rccFiles.push_back(absFile);
// qrc file entries
{
std::string entriesList = "{";
// Read input file list only for non generated .qrc files.
- if (!PropertyEnabled(sf, "GENERATED")) {
+ if (!sf->GetPropertyAsBool("GENERATED")) {
std::string error;
std::vector<std::string> files;
if (cmQtAutoGeneratorCommon::RccListInputs(
@@ -648,7 +700,7 @@ static void RccSetupAutoTarget(cmGeneratorTarget const* target,
}
}
entriesList += "}";
- _rcc_inputs.push_back(entriesList);
+ rccInputs.push_back(entriesList);
}
// rcc options for this qrc file
{
@@ -670,70 +722,50 @@ static void RccSetupAutoTarget(cmGeneratorTarget const* target,
}
AddDefinitionEscaped(makefile, "_qt_rcc_executable", rccCommand);
- AddDefinitionEscaped(makefile, "_rcc_files", _rcc_files);
- AddDefinitionEscaped(makefile, "_rcc_inputs", _rcc_inputs);
+ AddDefinitionEscaped(makefile, "_rcc_files", rccFiles);
+ AddDefinitionEscaped(makefile, "_rcc_inputs", rccInputs);
AddDefinitionEscaped(makefile, "_rcc_options_files", rccFileFiles);
AddDefinitionEscaped(makefile, "_rcc_options_options", rccFileOptions);
}
-void cmQtAutoGeneratorInitializer::InitializeAutogenSources(
- cmGeneratorTarget* target)
-{
- if (target->GetPropertyAsBool("AUTOMOC")) {
- cmMakefile* makefile = target->Target->GetMakefile();
- const std::vector<std::string> suffixes =
- GetConfigurationSuffixes(makefile);
- // Get build directory
- const std::string autogenBuildDir = GetAutogenTargetBuildDir(target);
- // Register all compilation files as generated
- for (std::vector<std::string>::const_iterator it = suffixes.begin();
- it != suffixes.end(); ++it) {
- std::string mcFile = autogenBuildDir + "/mocs_compilation";
- mcFile += *it;
- mcFile += ".cpp";
- AddGeneratedSource(makefile, mcFile, cmQtAutoGeneratorCommon::MOC);
- }
- // Mocs compilation file
- if (IsMultiConfig(target->GetGlobalGenerator())) {
- target->AddSource(autogenBuildDir + "/mocs_compilation_$<CONFIG>.cpp");
- } else {
- target->AddSource(autogenBuildDir + "/mocs_compilation.cpp");
- }
- }
-}
-
void cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
- cmLocalGenerator* lg, cmGeneratorTarget* target)
+ cmLocalGenerator* localGen, cmGeneratorTarget* target)
{
cmMakefile* makefile = target->Target->GetMakefile();
+ cmGlobalGenerator* globalGen = localGen->GetGlobalGenerator();
// Create a custom target for running generators at buildtime
const bool mocEnabled = target->GetPropertyAsBool("AUTOMOC");
const bool uicEnabled = target->GetPropertyAsBool("AUTOUIC");
const bool rccEnabled = target->GetPropertyAsBool("AUTORCC");
- const bool multiConfig = IsMultiConfig(target->GetGlobalGenerator());
+ const bool multiConfig = AutogenMultiConfig(globalGen);
const std::string autogenTargetName = GetAutogenTargetName(target);
const std::string autogenBuildDir = GetAutogenTargetBuildDir(target);
const std::string workingDirectory =
cmSystemTools::CollapseFullPath("", makefile->GetCurrentBinaryDirectory());
- const std::string qtMajorVersion = GetQtMajorVersion(target);
- const std::string rccCommand = RccGetExecutable(target, qtMajorVersion);
const std::vector<std::string> suffixes = GetConfigurationSuffixes(makefile);
- std::vector<std::string> autogenDepends;
+ std::set<std::string> autogenDependsSet;
std::vector<std::string> autogenProvides;
+ bool usePRE_BUILD = false;
+ if (globalGen->GetName().find("Visual Studio") != std::string::npos) {
+ // Under VS use a PRE_BUILD event instead of a separate target to
+ // reduce the number of targets loaded into the IDE.
+ // This also works around a VS 11 bug that may skip updating the target:
+ // https://connect.microsoft.com/VisualStudio/feedback/details/769495
+ usePRE_BUILD = true;
+ }
+
// Remove build directories on cleanup
- makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES",
- autogenBuildDir.c_str(), false);
+ AddCleanFile(makefile, autogenBuildDir);
// Remove old settings on cleanup
{
std::string base = GetAutogenTargetFilesDir(target);
+ base += "/AutogenOldSettings";
for (std::vector<std::string>::const_iterator it = suffixes.begin();
it != suffixes.end(); ++it) {
- std::string fname = base + "/AutogenOldSettings" + *it + ".cmake";
- makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES", fname.c_str(),
- false);
+ AddCleanFile(makefile, base + *it + ".cmake");
}
}
@@ -777,151 +809,173 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
// Add moc compilation to generated files list
if (mocEnabled) {
- for (std::vector<std::string>::const_iterator it = suffixes.begin();
- it != suffixes.end(); ++it) {
- std::string mcFile = autogenBuildDir + "/mocs_compilation";
- mcFile += *it;
- mcFile += ".cpp";
- autogenProvides.push_back(mcFile);
- }
+ const std::string mocsComp = autogenBuildDir + "/mocs_compilation.cpp";
+ AddGeneratedSource(target, mocsComp, cmQtAutoGeneratorCommon::MOC);
+ autogenProvides.push_back(mocsComp);
}
// Add autogen includes directory to the origin target INCLUDE_DIRECTORIES
if (mocEnabled || uicEnabled) {
+ std::string includeDir = autogenBuildDir + "/include";
if (multiConfig) {
- target->AddIncludeDirectory(autogenBuildDir + "/include_$<CONFIG>",
- true);
-
- } else {
- target->AddIncludeDirectory(autogenBuildDir + "/include", true);
+ includeDir += "_$<CONFIG>";
}
+ target->AddIncludeDirectory(includeDir, true);
}
-#if defined(_WIN32) && !defined(__CYGWIN__)
- bool usePRE_BUILD = false;
- cmGlobalGenerator* gg = lg->GetGlobalGenerator();
- if (gg->GetName().find("Visual Studio") != std::string::npos) {
- // Under VS use a PRE_BUILD event instead of a separate target to
- // reduce the number of targets loaded into the IDE.
- // This also works around a VS 11 bug that may skip updating the target:
- // https://connect.microsoft.com/VisualStudio/feedback/details/769495
- usePRE_BUILD = true;
+ // Add user defined autogen target dependencies
+ {
+ const std::string deps = GetSafeProperty(target, "AUTOGEN_TARGET_DEPENDS");
+ if (!deps.empty()) {
+ std::vector<std::string> extraDepends;
+ cmSystemTools::ExpandListArgument(deps, extraDepends);
+ autogenDependsSet.insert(extraDepends.begin(), extraDepends.end());
+ }
}
-#endif
-
- // Initialize autogen target dependencies
- if (const char* deps = target->GetProperty("AUTOGEN_TARGET_DEPENDS")) {
- cmSystemTools::ExpandListArgument(deps, autogenDepends);
+ // Add utility target dependencies to the autogen dependencies
+ {
+ const std::set<std::string>& utils = target->Target->GetUtilities();
+ for (std::set<std::string>::const_iterator it = utils.begin();
+ it != utils.end(); ++it) {
+ const std::string& targetName = *it;
+ if (makefile->FindTargetToUse(targetName) != nullptr) {
+ autogenDependsSet.insert(targetName);
+ }
+ }
}
- // Add link library targets to the autogen dependencies
+ // Add link library target dependencies to the autogen dependencies
{
const cmTarget::LinkLibraryVectorType& libVec =
target->Target->GetOriginalLinkLibraries();
for (cmTarget::LinkLibraryVectorType::const_iterator it = libVec.begin();
it != libVec.end(); ++it) {
const std::string& libName = it->first;
- if (makefile->FindTargetToUse(libName) != CM_NULLPTR) {
- autogenDepends.push_back(libName);
+ if (makefile->FindTargetToUse(libName) != nullptr) {
+ autogenDependsSet.insert(libName);
}
}
}
+
+ // Extract relevant source files
+ std::vector<std::string> generatedSources;
+ std::vector<std::pair<std::string, bool> > qrcSources;
{
- cmFilePathChecksum fpathCheckSum(makefile);
- // Iterate over all source files
+ const std::string qrcExt = "qrc";
std::vector<cmSourceFile*> srcFiles;
target->GetConfigCommonSourceFiles(srcFiles);
for (std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
fileIt != srcFiles.end(); ++fileIt) {
cmSourceFile* sf = *fileIt;
- if (!PropertyEnabled(sf, "SKIP_AUTOGEN")) {
- std::string const& ext = sf->GetExtension();
- // Add generated file that will be scanned by moc or uic to
- // the dependencies
- if (mocEnabled || uicEnabled) {
- const cmSystemTools::FileFormat fileType =
- cmSystemTools::GetFileFormat(ext.c_str());
- if ((fileType == cmSystemTools::CXX_FILE_FORMAT) ||
- (fileType == cmSystemTools::HEADER_FILE_FORMAT)) {
- if (PropertyEnabled(sf, "GENERATED")) {
- if ((mocEnabled && !PropertyEnabled(sf, "SKIP_AUTOMOC")) ||
- (uicEnabled && !PropertyEnabled(sf, "SKIP_AUTOUIC"))) {
- autogenDepends.push_back(
- cmsys::SystemTools::GetRealPath(sf->GetFullPath()));
-#if defined(_WIN32) && !defined(__CYGWIN__)
- // Cannot use PRE_BUILD with generated files
- usePRE_BUILD = false;
-#endif
- }
+ if (sf->GetPropertyAsBool("SKIP_AUTOGEN")) {
+ continue;
+ }
+ // sf->GetExtension() is only valid after sf->GetFullPath() ...
+ const std::string& fPath = sf->GetFullPath();
+ const std::string& ext = sf->GetExtension();
+ // Register generated files that will be scanned by moc or uic
+ if (mocEnabled || uicEnabled) {
+ const cmSystemTools::FileFormat fileType =
+ cmSystemTools::GetFileFormat(ext.c_str());
+ if ((fileType == cmSystemTools::CXX_FILE_FORMAT) ||
+ (fileType == cmSystemTools::HEADER_FILE_FORMAT)) {
+ if (sf->GetPropertyAsBool("GENERATED")) {
+ if ((mocEnabled && !sf->GetPropertyAsBool("SKIP_AUTOMOC")) ||
+ (uicEnabled && !sf->GetPropertyAsBool("SKIP_AUTOUIC"))) {
+ generatedSources.push_back(
+ cmsys::SystemTools::GetRealPath(fPath));
}
}
}
- // Process rcc enabled files
- if (rccEnabled && (ext == "qrc") &&
- !PropertyEnabled(sf, "SKIP_AUTORCC")) {
- const std::string absFile =
- cmsys::SystemTools::GetRealPath(sf->GetFullPath());
-
- // Compose rcc output file name
- {
- std::string rccOutBase = autogenBuildDir + "/";
- rccOutBase += fpathCheckSum.getPart(absFile);
- rccOutBase += "/qrc_";
- rccOutBase +=
- cmsys::SystemTools::GetFilenameWithoutLastExtension(absFile);
-
- // Register rcc ouput file as generated
- for (std::vector<std::string>::const_iterator it =
- suffixes.begin();
- it != suffixes.end(); ++it) {
- std::string rccOutCfg = rccOutBase;
- rccOutCfg += *it;
- rccOutCfg += ".cpp";
- AddGeneratedSource(makefile, rccOutCfg,
- cmQtAutoGeneratorCommon::RCC);
- autogenProvides.push_back(rccOutCfg);
- }
- // Add rcc output file to origin target sources
- if (multiConfig) {
- target->AddSource(rccOutBase + "_$<CONFIG>.cpp");
- } else {
- target->AddSource(rccOutBase + ".cpp");
- }
- }
+ }
+ // Register rcc enabled files
+ if (rccEnabled && (ext == qrcExt) &&
+ !sf->GetPropertyAsBool("SKIP_AUTORCC")) {
+ qrcSources.push_back(
+ std::pair<std::string, bool>(cmsys::SystemTools::GetRealPath(fPath),
+ sf->GetPropertyAsBool("GENERATED")));
+ }
+ }
+ // cmGeneratorTarget::GetConfigCommonSourceFiles computes the target's
+ // sources meta data cache. Clear it so that OBJECT library targets that
+ // are AUTOGEN initialized after this target get their added
+ // mocs_compilation.cpp source acknowledged by this target.
+ target->ClearSourcesCache();
+ }
+
+ if (!generatedSources.empty()) {
+ for (std::vector<std::string>::const_iterator it =
+ generatedSources.begin();
+ it != generatedSources.end(); ++it) {
+ autogenDependsSet.insert(*it);
+ }
+ }
+
+ if (!qrcSources.empty()) {
+ const std::string qtMajorVersion = GetQtMajorVersion(target);
+ const std::string rccCommand = RccGetExecutable(target, qtMajorVersion);
+ const cmFilePathChecksum fpathCheckSum(makefile);
+ for (std::vector<std::pair<std::string, bool> >::const_iterator it =
+ qrcSources.begin();
+ it != qrcSources.end(); ++it) {
+ const std::string& absFile = it->first;
+
+ // Compose rcc output file name
+ {
+ std::string rccBuildFile = autogenBuildDir + "/";
+ rccBuildFile += fpathCheckSum.getPart(absFile);
+ rccBuildFile += "/qrc_";
+ rccBuildFile +=
+ cmsys::SystemTools::GetFilenameWithoutLastExtension(absFile);
+ rccBuildFile += ".cpp";
+
+ // Register rcc ouput file as generated
+ AddGeneratedSource(target, rccBuildFile, cmQtAutoGeneratorCommon::RCC);
+ // Register rcc ouput file as generated by the _autogen target
+ autogenProvides.push_back(rccBuildFile);
+ }
- if (PropertyEnabled(sf, "GENERATED")) {
- // Add generated qrc file to the dependencies
- autogenDepends.push_back(absFile);
+ if (it->second) {
+ // Add generated qrc file to the dependencies
+ autogenDependsSet.insert(absFile);
+ } else {
+ // Run cmake again when .qrc file changes
+ makefile->AddCMakeDependFile(absFile);
+ // Add the qrc input files to the dependencies
+ {
+ std::string error;
+ std::vector<std::string> extraDepends;
+ if (cmQtAutoGeneratorCommon::RccListInputs(
+ qtMajorVersion, rccCommand, absFile, extraDepends, &error)) {
+ autogenDependsSet.insert(extraDepends.begin(), extraDepends.end());
} else {
- // Run cmake again when .qrc file changes
- makefile->AddCMakeDependFile(absFile);
-
- // Add the qrc input files to the dependencies
- std::string error;
- if (!cmQtAutoGeneratorCommon::RccListInputs(
- qtMajorVersion, rccCommand, absFile, autogenDepends,
- &error)) {
- cmSystemTools::Error(error.c_str());
- }
+ cmSystemTools::Error(error.c_str());
}
-#if defined(_WIN32) && !defined(__CYGWIN__)
- // Cannot use PRE_BUILD because the resource files themselves
- // may not be sources within the target so VS may not know the
- // target needs to re-build at all.
- usePRE_BUILD = false;
-#endif
}
}
}
}
-#if defined(_WIN32) && !defined(__CYGWIN__)
+ // Convert std::set to std::vector
+ const std::vector<std::string> autogenDepends(autogenDependsSet.begin(),
+ autogenDependsSet.end());
+ // Disable PRE_BUILD on demand
if (usePRE_BUILD) {
- // If the autogen target depends on an other target don't use PRE_BUILD
- for (std::vector<std::string>::iterator it = autogenDepends.begin();
- it != autogenDepends.end(); ++it) {
- if (makefile->FindTargetToUse(*it) != CM_NULLPTR) {
- usePRE_BUILD = false;
- break;
+ if (!generatedSources.empty() || !qrcSources.empty()) {
+ // - Cannot use PRE_BUILD with generated files
+ // - Cannot use PRE_BUILD because the resource files themselves
+ // may not be sources within the target so VS may not know the
+ // target needs to re-build at all.
+ usePRE_BUILD = false;
+ }
+ if (usePRE_BUILD) {
+ // If the autogen target depends on an other target don't use PRE_BUILD
+ for (std::vector<std::string>::const_iterator it =
+ autogenDepends.begin();
+ it != autogenDepends.end(); ++it) {
+ if (makefile->FindTargetToUse(*it) != nullptr) {
+ usePRE_BUILD = false;
+ break;
+ }
}
}
}
@@ -936,31 +990,33 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
cc.SetEscapeOldStyle(false);
cc.SetEscapeAllowMakeVars(true);
target->Target->AddPreBuildCommand(cc);
- } else
-#endif
- {
+ } else {
cmTarget* autogenTarget = makefile->AddUtilityCommand(
autogenTargetName, true, workingDirectory.c_str(),
/*byproducts=*/autogenProvides, autogenDepends, commandLines, false,
autogenComment.c_str());
- cmGeneratorTarget* gt = new cmGeneratorTarget(autogenTarget, lg);
- lg->AddGeneratorTarget(gt);
+ localGen->AddGeneratorTarget(
+ new cmGeneratorTarget(autogenTarget, localGen));
- // Set target folder
- const char* autogenFolder =
- makefile->GetState()->GetGlobalProperty("AUTOMOC_TARGETS_FOLDER");
- if (!autogenFolder) {
- autogenFolder =
- makefile->GetState()->GetGlobalProperty("AUTOGEN_TARGETS_FOLDER");
- }
- if (autogenFolder && *autogenFolder) {
- autogenTarget->SetProperty("FOLDER", autogenFolder);
- } else {
- // inherit FOLDER property from target (#13688)
- utilCopyTargetProperty(gt->Target, target->Target, "FOLDER");
+ // Set autogen target FOLDER
+ {
+ const char* autogenFolder =
+ makefile->GetState()->GetGlobalProperty("AUTOMOC_TARGETS_FOLDER");
+ if (autogenFolder == nullptr) {
+ autogenFolder =
+ makefile->GetState()->GetGlobalProperty("AUTOGEN_TARGETS_FOLDER");
+ }
+ // Inherit FOLDER property from target (#13688)
+ if (autogenFolder == nullptr) {
+ autogenFolder = target->Target->GetProperty("FOLDER");
+ }
+ if ((autogenFolder != nullptr) && (*autogenFolder != '\0')) {
+ autogenTarget->SetProperty("FOLDER", autogenFolder);
+ }
}
+ // Add autogen target to the origin target dependencies
target->Target->AddUtility(autogenTargetName);
}
}
@@ -978,54 +1034,46 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
std::string config;
const std::vector<std::string> configs(GetConfigurations(makefile, &config));
- // Configurations settings buffers
+ // Configuration suffixes
std::map<std::string, std::string> configSuffix;
- std::map<std::string, std::string> configMocIncludes;
- std::map<std::string, std::string> configMocDefines;
- std::map<std::string, std::string> configUicOptions;
-
- // Configuration suffix
- if (IsMultiConfig(target->GetGlobalGenerator())) {
+ if (AutogenMultiConfig(target->GetGlobalGenerator())) {
for (std::vector<std::string>::const_iterator it = configs.begin();
it != configs.end(); ++it) {
configSuffix[*it] = "_" + *it;
}
}
+ // Configurations settings buffers
+ AutogenSetup setup;
+
// Basic setup
{
const bool mocEnabled = target->GetPropertyAsBool("AUTOMOC");
const bool uicEnabled = target->GetPropertyAsBool("AUTOUIC");
const bool rccEnabled = target->GetPropertyAsBool("AUTORCC");
- const std::string autogenTargetName = GetAutogenTargetName(target);
const std::string qtMajorVersion = GetQtMajorVersion(target);
-
- std::vector<std::string> sources;
- std::vector<std::string> headers;
-
- if (mocEnabled || uicEnabled || rccEnabled) {
- std::vector<std::string> mocSkipList;
- std::vector<std::string> uicSkipList;
- AcquireScanFiles(target, sources, headers, mocSkipList, uicSkipList);
- if (mocEnabled) {
- MocSetupAutoTarget(target, autogenTargetName, qtMajorVersion, config,
- configs, mocSkipList, configMocIncludes,
- configMocDefines);
- }
- if (uicEnabled) {
- UicSetupAutoTarget(target, qtMajorVersion, config, configs,
- uicSkipList, configUicOptions);
+ {
+ std::vector<cmSourceFile*> srcFiles;
+ target->GetConfigCommonSourceFiles(srcFiles);
+ if (mocEnabled || uicEnabled) {
+ SetupAcquireScanFiles(target, mocEnabled, uicEnabled, srcFiles, setup);
+ if (mocEnabled) {
+ SetupAutoTargetMoc(target, qtMajorVersion, config, configs, setup);
+ }
+ if (uicEnabled) {
+ SetupAutoTargetUic(target, qtMajorVersion, config, configs, setup);
+ }
}
if (rccEnabled) {
- RccSetupAutoTarget(target, qtMajorVersion);
+ SetupAutoTargetRcc(target, qtMajorVersion, srcFiles);
}
}
- AddDefinitionEscaped(makefile, "_autogen_build_dir",
+ AddDefinitionEscaped(makefile, "_build_dir",
GetAutogenTargetBuildDir(target));
AddDefinitionEscaped(makefile, "_qt_version_major", qtMajorVersion);
- AddDefinitionEscaped(makefile, "_sources", sources);
- AddDefinitionEscaped(makefile, "_headers", headers);
+ AddDefinitionEscaped(makefile, "_sources", setup.sources);
+ AddDefinitionEscaped(makefile, "_headers", setup.headers);
}
// Generate info file
@@ -1038,8 +1086,8 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
}
// Append custom definitions to info file on demand
- if (!configSuffix.empty() || !configMocDefines.empty() ||
- !configMocIncludes.empty() || !configUicOptions.empty()) {
+ if (!configSuffix.empty() || !setup.configMocDefines.empty() ||
+ !setup.configMocIncludes.empty() || !setup.configUicOptions.empty()) {
// Ensure we have write permission in case .in was read-only.
mode_t perm = 0;
@@ -1061,29 +1109,29 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
it = configSuffix.begin(),
end = configSuffix.end();
it != end; ++it) {
- ofs << "set(AM_CONFIG_SUFFIX_" << it->first << " " << it->second
- << ")\n";
+ ofs << "set(AM_CONFIG_SUFFIX_" << it->first << " "
+ << cmOutputConverter::EscapeForCMake(it->second) << ")\n";
}
for (std::map<std::string, std::string>::iterator
- it = configMocDefines.begin(),
- end = configMocDefines.end();
+ it = setup.configMocDefines.begin(),
+ end = setup.configMocDefines.end();
it != end; ++it) {
- ofs << "set(AM_MOC_DEFINITIONS_" << it->first << " " << it->second
- << ")\n";
+ ofs << "set(AM_MOC_DEFINITIONS_" << it->first << " "
+ << cmOutputConverter::EscapeForCMake(it->second) << ")\n";
}
for (std::map<std::string, std::string>::iterator
- it = configMocIncludes.begin(),
- end = configMocIncludes.end();
+ it = setup.configMocIncludes.begin(),
+ end = setup.configMocIncludes.end();
it != end; ++it) {
- ofs << "set(AM_MOC_INCLUDES_" << it->first << " " << it->second
- << ")\n";
+ ofs << "set(AM_MOC_INCLUDES_" << it->first << " "
+ << cmOutputConverter::EscapeForCMake(it->second) << ")\n";
}
for (std::map<std::string, std::string>::iterator
- it = configUicOptions.begin(),
- end = configUicOptions.end();
+ it = setup.configUicOptions.begin(),
+ end = setup.configUicOptions.end();
it != end; ++it) {
- ofs << "set(AM_UIC_TARGET_OPTIONS_" << it->first << " " << it->second
- << ")\n";
+ ofs << "set(AM_UIC_TARGET_OPTIONS_" << it->first << " "
+ << cmOutputConverter::EscapeForCMake(it->second) << ")\n";
}
} else {
// File open error
generated by cgit v0.12 at 2024-10-19 01:48:52 (GMT)