CMake/Source/cmGlobalGenerator.h

577 lines
21 KiB
C
Raw Normal View History

Simplify CMake per-source license notices Per-source copyright/license notice headers that spell out copyright holder names and years are hard to maintain and often out-of-date or plain wrong. Precise contributor information is already maintained automatically by the version control tool. Ultimately it is the receiver of a file who is responsible for determining its licensing status, and per-source notices are merely a convenience. Therefore it is simpler and more accurate for each source to have a generic notice of the license name and references to more detailed information on copyright holders and full license terms. Our `Copyright.txt` file now contains a list of Contributors whose names appeared source-level copyright notices. It also references version control history for more precise information. Therefore we no longer need to spell out the list of Contributors in each source file notice. Replace CMake per-source copyright/license notice headers with a short description of the license and links to `Copyright.txt` and online information available from "https://cmake.org/licensing". The online URL also handles cases of modules being copied out of our source into other projects, so we can drop our notices about replacing links with full license text. Run the `Utilities/Scripts/filter-notices.bash` script to perform the majority of the replacements mechanically. Manually fix up shebang lines and trailing newlines in a few files. Manually update the notices in a few files that the script does not handle.
2016-09-27 22:01:08 +03:00
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
2002-08-31 00:00:35 +04:00
#ifndef cmGlobalGenerator_h
#define cmGlobalGenerator_h
#include <cmConfigure.h>
#include "cmExportSetMap.h"
#include "cmState.h"
#include "cmSystemTools.h"
#include "cmTarget.h"
#include "cmTargetDepend.h"
#include <iosfwd>
#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>
#if defined(CMAKE_BUILD_WITH_CMAKE)
#include "cmFileLockPool.h"
#ifdef CMake_HAVE_CXX_UNORDERED_MAP
#include <unordered_map>
#else
#include <cmsys/hash_map.hxx>
#endif
#endif
class cmCustomCommandLines;
class cmSourceFile;
class cmExportBuildFileGenerator;
class cmExternalMakefileProjectGenerator;
class cmGeneratorTarget;
2002-08-31 00:00:35 +04:00
class cmLocalGenerator;
class cmMakefile;
class cmake;
2002-08-31 00:00:35 +04:00
/** \class cmGlobalGenerator
2014-10-10 03:22:45 +04:00
* \brief Responsible for overseeing the generation process for the entire tree
2002-08-31 00:00:35 +04:00
*
* Subclasses of this class generate makefiles for various
* platforms.
*/
class cmGlobalGenerator
{
public:
///! Free any memory allocated with the GlobalGenerator
cmGlobalGenerator(cmake* cm);
2002-08-31 00:00:35 +04:00
virtual ~cmGlobalGenerator();
2010-11-12 00:02:07 +03:00
virtual cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf);
2002-08-31 00:00:35 +04:00
///! Get the name for this generator
virtual std::string GetName() const { return "Generic"; }
2010-11-12 00:02:07 +03:00
/** Check whether the given name matches the current generator. */
virtual bool MatchesGeneratorName(const std::string& name) const
{
return this->GetName() == name;
}
/** Tell the generator about the target system. */
virtual bool SetSystemName(std::string const&, cmMakefile*) { return true; }
/** Set the generator-specific platform name. Returns true if platform
is supported and false otherwise. */
virtual bool SetGeneratorPlatform(std::string const& p, cmMakefile* mf);
/** Set the generator-specific toolset name. Returns true if toolset
is supported and false otherwise. */
virtual bool SetGeneratorToolset(std::string const& ts, cmMakefile* mf);
2002-08-31 00:00:35 +04:00
/**
* Create LocalGenerators and process the CMakeLists files. This does not
2010-11-12 00:02:07 +03:00
* actually produce any makefiles, DSPs, etc.
2002-08-31 00:00:35 +04:00
*/
virtual void Configure();
bool Compute();
virtual void AddExtraIDETargets() {}
enum TargetTypes
{
AllTargets,
ImportedOnly
};
void CreateImportedGenerationObjects(
cmMakefile* mf, std::vector<std::string> const& targets,
std::vector<cmGeneratorTarget const*>& exports);
void CreateGenerationObjects(TargetTypes targetTypes = AllTargets);
2002-08-31 00:00:35 +04:00
/**
* Generate the all required files for building this project/tree. This
* basically creates a series of LocalGenerators for each directory and
2010-11-12 00:02:07 +03:00
* requests that they Generate.
2002-08-31 00:00:35 +04:00
*/
virtual void Generate();
2002-08-31 00:00:35 +04:00
/**
2010-11-12 00:02:07 +03:00
* Set/Get and Clear the enabled languages.
2002-08-31 00:00:35 +04:00
*/
void SetLanguageEnabled(const std::string&, cmMakefile* mf);
bool GetLanguageEnabled(const std::string&) const;
2002-08-31 00:00:35 +04:00
void ClearEnabledLanguages();
void GetEnabledLanguages(std::vector<std::string>& lang) const;
2002-08-31 00:00:35 +04:00
/**
2014-10-10 03:22:45 +04:00
* Try to determine system information such as shared library
2010-11-12 00:02:07 +03:00
* extension, pthreads, byte order etc.
2002-08-31 00:00:35 +04:00
*/
virtual void EnableLanguage(std::vector<std::string> const& languages,
cmMakefile*, bool optional);
2002-08-31 00:00:35 +04:00
/**
* Resolve the CMAKE_<lang>_COMPILER setting for the given language.
* Intended to be called from EnableLanguage.
*/
void ResolveLanguageCompiler(const std::string& lang, cmMakefile* mf,
bool optional) const;
2002-09-13 18:42:50 +04:00
/**
2014-10-10 03:22:45 +04:00
* Try to determine system information, get it from another generator
2002-09-13 18:42:50 +04:00
*/
void EnableLanguagesFromGenerator(cmGlobalGenerator* gen, cmMakefile* mf);
2002-09-13 18:42:50 +04:00
2002-08-31 00:00:35 +04:00
/**
2011-03-19 13:41:00 +03:00
* Try running cmake and building a file. This is used for dynamically
2002-08-31 00:00:35 +04:00
* loaded commands, not as part of the usual build process.
*/
int TryCompile(const std::string& srcdir, const std::string& bindir,
const std::string& projectName, const std::string& targetName,
bool fast, std::string& output, cmMakefile* mf);
2010-11-12 00:02:07 +03:00
/**
* Build a file given the following information. This is a more direct call
* that is used by both CTest and TryCompile. If target name is NULL or
* empty then all is assumed. clean indicates if a "make clean" should be
* done first.
*/
2014-02-25 02:38:30 +04:00
int Build(const std::string& srcdir, const std::string& bindir,
const std::string& projectName, const std::string& targetName,
std::string& output, const std::string& makeProgram,
const std::string& config, bool clean, bool fast, bool verbose,
double timeout, cmSystemTools::OutputOption outputflag =
cmSystemTools::OUTPUT_NONE,
std::vector<std::string> const& nativeOptions =
std::vector<std::string>());
2010-11-12 00:02:07 +03:00
virtual void GenerateBuildCommand(
std::vector<std::string>& makeCommand, const std::string& makeProgram,
2014-02-25 02:38:30 +04:00
const std::string& projectName, const std::string& projectDir,
const std::string& targetName, const std::string& config, bool fast,
bool verbose,
std::vector<std::string> const& makeOptions = std::vector<std::string>());
2010-11-12 00:02:07 +03:00
/** Generate a "cmake --build" call for a given target and config. */
2014-02-07 02:31:47 +04:00
std::string GenerateCMakeBuildCommand(const std::string& target,
const std::string& config,
const std::string& native,
bool ignoreErrors);
2002-08-31 00:00:35 +04:00
///! Get the CMake instance
cmake* GetCMakeInstance() const { return this->CMakeInstance; }
2006-03-15 19:02:08 +03:00
void SetConfiguredFilesPath(cmGlobalGenerator* gen);
const std::vector<cmMakefile*>& GetMakefiles() const
{
return this->Makefiles;
}
const std::vector<cmLocalGenerator*>& GetLocalGenerators() const
{
return this->LocalGenerators;
}
cmMakefile* GetCurrentMakefile() const { return this->CurrentMakefile; }
void SetCurrentMakefile(cmMakefile* mf) { this->CurrentMakefile = mf; }
void AddMakefile(cmMakefile* mf);
///! Set an generator for an "external makefile based project"
void SetExternalMakefileProjectGenerator(
cmExternalMakefileProjectGenerator* extraGenerator);
std::string GetExtraGeneratorName() const;
void AddInstallComponent(const char* component);
const std::set<std::string>* GetInstallComponents() const
{
return &this->InstallComponents;
}
ENH: Further refinement of the CPack components functionality from Doug Gregor. Details: ========== - New cpack_add_component, cpack_add_component_group, and cpack_add_install_type "commands" defined as macros in the CPack module. - Documentation for all of the variables and commands in the CPack module. - Added get_cmake_property(... COMPONENTS) to CMake to ask for the names of all components. Used in the CPack module to automatically build component-based installers. (Set CPACK_MONOLITHIC_INSTALL to turn off component-based installation). - A group can declare its PARENT_GROUP, to build an arbitrary hierarchy of groups. - New CPack command cpack_configure_downloads, which creates an installer that downloads only the selected components on-the-fly. Those components marked DOWNLOADED will be separate packages downloaded on-the-fly (or, all packages can be marked as such with the ALL option to cpack_configure_downloads). Individual components are compressed with ZIP at installer-creation time and downloaded/uncompressed by the installer as needed. This feature is only available on Windows with NSIS at the moment. - NSIS installers can install themselves and enable the "Change" button in Add/Remove programs, allowing users to go back and install or remove components. This can be disabled through cpack_configure_downloads, because it's only really useful is most of the application's functionality is in downloaded components. - Bug fix: automatically install everything whose COMPONENT was not specified (it's a hidden, required group) - Bug fix: fixed removal of components when re-running the NSIS installer and unchecking components - Bug fix: NSIS installers now only install/remove the minimal number of files when re-run to update the installation (or by clicking "Change" in Add/Remove programs)
2008-07-08 19:52:25 +04:00
cmExportSetMap& GetExportSets() { return this->ExportSets; }
/** Add a file to the manifest of generated targets for a configuration. */
void AddToManifest(std::string const& f);
void EnableInstallTarget();
int TryCompileTimeout;
2010-11-12 00:02:07 +03:00
bool GetForceUnixPaths() const { return this->ForceUnixPaths; }
bool GetToolSupportsColor() const { return this->ToolSupportsColor; }
///! return the language for the given extension
std::string GetLanguageFromExtension(const char* ext) const;
///! is an extension to be ignored
bool IgnoreFile(const char* ext) const;
2014-10-10 03:22:45 +04:00
///! What is the preference for linkers and this language (None or Preferred)
int GetLinkerPreference(const std::string& lang) const;
///! What is the object file extension for a given source file?
std::string GetLanguageOutputExtension(cmSourceFile const&) const;
2006-02-25 01:35:35 +03:00
///! What is the configurations directory variable called?
virtual const char* GetCMakeCFGIntDir() const { return "."; }
2006-02-25 01:35:35 +03:00
///! expand CFGIntDir for a configuration
virtual std::string ExpandCFGIntDir(const std::string& str,
const std::string& config) const;
/** Get whether the generator should use a script for link commands. */
bool GetUseLinkScript() const { return this->UseLinkScript; }
/** Get whether the generator should produce special marks on rules
producing symbolic (non-file) outputs. */
bool GetNeedSymbolicMark() const { return this->NeedSymbolicMark; }
2005-05-02 23:50:42 +04:00
/*
* Determine what program to use for building the project.
*/
virtual void FindMakeProgram(cmMakefile*);
2005-05-02 23:50:42 +04:00
///! Find a target by name by searching the local generators.
cmTarget* FindTarget(const std::string& name,
bool excludeAliases = false) const;
cmGeneratorTarget* FindGeneratorTarget(const std::string& name) const;
void AddAlias(const std::string& name, const std::string& tgtName);
2014-02-07 02:31:47 +04:00
bool IsAlias(const std::string& name) const;
/** Determine if a name resolves to a framework on disk or a built target
that is a framework. */
bool NameResolvesToFramework(const std::string& libname) const;
cmMakefile* FindMakefile(const std::string& start_dir) const;
///! Find a local generator by its startdirectory
2014-02-07 02:31:47 +04:00
cmLocalGenerator* FindLocalGenerator(const std::string& start_dir) const;
/** Append the subdirectory for the given configuration. If anything is
appended the given prefix and suffix will be appended around it, which
is useful for leading or trailing slashes. */
virtual void AppendDirectoryForConfig(const std::string& prefix,
const std::string& config,
const std::string& suffix,
std::string& dir);
/** Get the content of a directory. Directory listings are cached
and re-loaded from disk only when modified. During the generation
step the content will include the target files to be built even if
they do not yet exist. */
std::set<std::string> const& GetDirectoryContent(std::string const& dir,
bool needDisk = true);
void IndexTarget(cmTarget* t);
void IndexGeneratorTarget(cmGeneratorTarget* gt);
static bool IsReservedTarget(std::string const& name);
virtual const char* GetAllTargetName() const { return "ALL_BUILD"; }
virtual const char* GetInstallTargetName() const { return "INSTALL"; }
2016-06-27 23:44:16 +03:00
virtual const char* GetInstallLocalTargetName() const { return CM_NULLPTR; }
virtual const char* GetInstallStripTargetName() const { return CM_NULLPTR; }
virtual const char* GetPreinstallTargetName() const { return CM_NULLPTR; }
virtual const char* GetTestTargetName() const { return "RUN_TESTS"; }
virtual const char* GetPackageTargetName() const { return "PACKAGE"; }
2016-06-27 23:44:16 +03:00
virtual const char* GetPackageSourceTargetName() const { return CM_NULLPTR; }
virtual const char* GetEditCacheTargetName() const { return CM_NULLPTR; }
virtual const char* GetRebuildCacheTargetName() const { return CM_NULLPTR; }
virtual const char* GetCleanTargetName() const { return CM_NULLPTR; }
// Lookup edit_cache target command preferred by this generator.
virtual std::string GetEditCacheCommand() const { return ""; }
// Class to track a set of dependencies.
typedef cmTargetDependSet TargetDependSet;
// what targets does the specified target depend on directly
// via a target_link_libraries or add_dependencies
TargetDependSet const& GetTargetDirectDepends(
const cmGeneratorTarget* target);
const std::map<std::string, std::vector<cmLocalGenerator*> >& GetProjectMap()
const
{
return this->ProjectMap;
}
// track files replaced during a Generate
void FileReplacedDuringGenerate(const std::string& filename);
void GetFilesReplacedDuringGenerate(std::vector<std::string>& filenames);
void AddRuleHash(const std::vector<std::string>& outputs,
std::string const& content);
/** Return whether the given binary directory is unused. */
bool BinaryDirectoryIsNew(const std::string& dir)
{
return this->BinaryDirectories.insert(dir).second;
}
/** Return true if the generated build tree may contain multiple builds.
i.e. "Can I build Debug and Release in the same tree?" */
virtual bool IsMultiConfig() const { return false; }
std::string GetSharedLibFlagsForLanguage(std::string const& lang) const;
/** Generate an <output>.rule file path for a given command output. */
virtual std::string GenerateRuleFile(std::string const& output) const;
static std::string EscapeJSON(const std::string& s);
void ProcessEvaluationFiles();
std::map<std::string, cmExportBuildFileGenerator*>& GetBuildExportSets()
{
return this->BuildExportSets;
}
void AddBuildExportSet(cmExportBuildFileGenerator*);
void AddBuildExportExportSet(cmExportBuildFileGenerator*);
bool IsExportedTargetsFile(const std::string& filename) const;
bool GenerateImportFile(const std::string& file);
cmExportBuildFileGenerator* GetExportedTargetsFile(
const std::string& filename) const;
void AddCMP0042WarnTarget(const std::string& target);
virtual void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const;
bool GenerateCPackPropertiesFile();
void CreateEvaluationSourceFiles(std::string const& config) const;
void SetFilenameTargetDepends(
cmSourceFile* sf, std::set<cmGeneratorTarget const*> const& tgts);
const std::set<const cmGeneratorTarget*>& GetFilenameTargetDepends(
cmSourceFile* sf) const;
#if defined(CMAKE_BUILD_WITH_CMAKE)
cmFileLockPool& GetFileLockPool() { return FileLockPool; }
#endif
bool GetConfigureDoneCMP0026() const
{
return this->ConfigureDoneCMP0026AndCMP0024;
}
std::string MakeSilentFlag;
2002-08-31 00:00:35 +04:00
protected:
typedef std::vector<cmLocalGenerator*> GeneratorVector;
// for a project collect all its targets by following depend
// information, and also collect all the targets
void GetTargetSets(TargetDependSet& projectTargets,
TargetDependSet& originalTargets, cmLocalGenerator* root,
GeneratorVector const&);
bool IsRootOnlyTarget(cmGeneratorTarget* target) const;
void AddTargetDepends(const cmGeneratorTarget* target,
TargetDependSet& projectTargets);
void SetLanguageEnabledFlag(const std::string& l, cmMakefile* mf);
void SetLanguageEnabledMaps(const std::string& l, cmMakefile* mf);
void FillExtensionToLanguageMap(const std::string& l, cmMakefile* mf);
virtual bool CheckLanguages(std::vector<std::string> const& languages,
cmMakefile* mf) const;
virtual void PrintCompilerAdvice(std::ostream& os, std::string const& lang,
const char* envVar) const;
virtual bool ComputeTargetDepends();
virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const;
std::vector<const cmGeneratorTarget*> CreateQtAutoGeneratorsTargets();
std::string SelectMakeProgram(const std::string& makeProgram,
const std::string& makeDefault = "") const;
2010-11-12 00:02:07 +03:00
// Fill the ProjectMap, this must be called after LocalGenerators
2006-03-10 21:54:57 +03:00
// has been populated.
void FillProjectMap();
2015-08-02 13:44:07 +03:00
void CheckTargetProperties();
bool IsExcluded(cmState::Snapshot const& root,
cmState::Snapshot const& snp) const;
bool IsExcluded(cmLocalGenerator* root, cmLocalGenerator* gen) const;
bool IsExcluded(cmLocalGenerator* root, cmGeneratorTarget* target) const;
virtual void InitializeProgressMarks() {}
struct GlobalTargetInfo
{
std::string Name;
std::string Message;
cmCustomCommandLines CommandLines;
std::vector<std::string> Depends;
std::string WorkingDir;
bool UsesTerminal;
GlobalTargetInfo()
: UsesTerminal(false)
{
}
};
void CreateDefaultGlobalTargets(std::vector<GlobalTargetInfo>& targets);
void AddGlobalTarget_Package(std::vector<GlobalTargetInfo>& targets);
void AddGlobalTarget_PackageSource(std::vector<GlobalTargetInfo>& targets);
void AddGlobalTarget_Test(std::vector<GlobalTargetInfo>& targets);
void AddGlobalTarget_EditCache(std::vector<GlobalTargetInfo>& targets);
void AddGlobalTarget_RebuildCache(std::vector<GlobalTargetInfo>& targets);
void AddGlobalTarget_Install(std::vector<GlobalTargetInfo>& targets);
cmTarget CreateGlobalTarget(GlobalTargetInfo const& gti, cmMakefile* mf);
2006-02-23 18:07:24 +03:00
std::string FindMakeProgramFile;
std::string ConfiguredFilesPath;
cmake* CMakeInstance;
std::vector<cmMakefile*> Makefiles;
std::vector<cmLocalGenerator*> LocalGenerators;
cmMakefile* CurrentMakefile;
// map from project name to vector of local generators in that project
std::map<std::string, std::vector<cmLocalGenerator*> > ProjectMap;
2002-08-31 00:00:35 +04:00
// Set of named installation components requested by the project.
std::set<std::string> InstallComponents;
// Sets of named target exports
cmExportSetMap ExportSets;
std::map<std::string, cmExportBuildFileGenerator*> BuildExportSets;
std::map<std::string, cmExportBuildFileGenerator*> BuildExportExportSets;
std::map<std::string, std::string> AliasTargets;
cmTarget* FindTargetImpl(std::string const& name) const;
cmGeneratorTarget* FindGeneratorTargetImpl(std::string const& name) const;
cmGeneratorTarget* FindImportedGeneratorTargetImpl(
std::string const& name) const;
const char* GetPredefinedTargetsFolder();
virtual bool UseFolderProperty();
2002-08-31 00:00:35 +04:00
private:
#if defined(CMAKE_BUILD_WITH_CMAKE)
#ifdef CMake_HAVE_CXX_UNORDERED_MAP
typedef std::unordered_map<std::string, cmTarget*> TargetMap;
typedef std::unordered_map<std::string, cmGeneratorTarget*>
GeneratorTargetMap;
typedef std::unordered_map<std::string, cmMakefile*> MakefileMap;
#else
typedef cmsys::hash_map<std::string, cmTarget*> TargetMap;
typedef cmsys::hash_map<std::string, cmGeneratorTarget*> GeneratorTargetMap;
typedef cmsys::hash_map<std::string, cmMakefile*> MakefileMap;
#endif
#else
typedef std::map<std::string, cmTarget*> TargetMap;
typedef std::map<std::string, cmGeneratorTarget*> GeneratorTargetMap;
typedef std::map<std::string, cmMakefile*> MakefileMap;
#endif
// Map efficiently from target name to cmTarget instance.
// Do not use this structure for looping over all targets.
// It contains both normal and globally visible imported targets.
TargetMap TargetSearchIndex;
GeneratorTargetMap GeneratorTargetSearchIndex;
// Map efficiently from source directory path to cmMakefile instance.
// Do not use this structure for looping over all directories.
// It may not contain all of them (see note in IndexMakefile method).
MakefileMap MakefileSearchIndex;
cmMakefile* TryCompileOuterMakefile;
// If you add a new map here, make sure it is copied
2010-11-12 00:02:07 +03:00
// in EnableLanguagesFromGenerator
std::map<std::string, bool> IgnoreExtensions;
std::set<std::string> LanguagesReady; // Ready for try_compile
std::set<std::string> LanguagesInProgress;
std::map<std::string, std::string> OutputExtensions;
std::map<std::string, std::string> LanguageToOutputExtension;
std::map<std::string, std::string> ExtensionToLanguage;
std::map<std::string, int> LanguageToLinkerPreference;
std::map<std::string, std::string> LanguageToOriginalSharedLibFlags;
// Record hashes for rules and outputs.
struct RuleHash
{
char Data[32];
};
std::map<std::string, RuleHash> RuleHashes;
void CheckRuleHashes();
void CheckRuleHashes(std::string const& pfile, std::string const& home);
void WriteRuleHashes(std::string const& pfile);
void WriteSummary();
void WriteSummary(cmGeneratorTarget* target);
void FinalizeTargetCompileInfo();
virtual void ForceLinkerLanguages();
void CreateLocalGenerators();
void CheckCompilerIdCompatibility(cmMakefile* mf,
std::string const& lang) const;
void ComputeBuildFileGenerators();
cmExternalMakefileProjectGenerator* ExtraGenerator;
// track files replaced during a Generate
std::vector<std::string> FilesReplacedDuringGenerate;
// Store computed inter-target dependencies.
typedef std::map<cmGeneratorTarget const*, TargetDependSet> TargetDependMap;
TargetDependMap TargetDependencies;
friend class cmake;
void CreateGeneratorTargets(
TargetTypes targetTypes, cmMakefile* mf, cmLocalGenerator* lg,
std::map<cmTarget*, cmGeneratorTarget*> const& importedMap);
void CreateGeneratorTargets(TargetTypes targetTypes);
void ClearGeneratorMembers();
void IndexMakefile(cmMakefile* mf);
2016-06-27 23:44:16 +03:00
virtual const char* GetBuildIgnoreErrorsFlag() const { return CM_NULLPTR; }
// Cache directory content and target files to be built.
struct DirectoryContent
{
long LastDiskTime;
std::set<std::string> All;
std::set<std::string> Generated;
DirectoryContent()
: LastDiskTime(-1)
{
}
DirectoryContent(DirectoryContent const& dc)
: LastDiskTime(dc.LastDiskTime)
, All(dc.All)
, Generated(dc.Generated)
{
}
};
std::map<std::string, DirectoryContent> DirectoryContentMap;
// Set of binary directories on disk.
std::set<std::string> BinaryDirectories;
// track targets to issue CMP0042 warning for.
std::set<std::string> CMP0042WarnTargets;
mutable std::map<cmSourceFile*, std::set<cmGeneratorTarget const*> >
FilenameTargetDepends;
#if defined(CMAKE_BUILD_WITH_CMAKE)
// Pool of file locks
cmFileLockPool FileLockPool;
#endif
protected:
float FirstTimeProgress;
bool NeedSymbolicMark;
bool UseLinkScript;
bool ForceUnixPaths;
bool ToolSupportsColor;
bool InstallTargetEnabled;
bool ConfigureDoneCMP0026AndCMP0024;
2002-08-31 00:00:35 +04:00
};
#endif