CMake/Source/cmGlobalGenerator.h

403 lines
16 KiB
C
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
2002-08-30 20:00:35 +00:00
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
2002-08-30 20:00:35 +00:00
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
2002-08-30 20:00:35 +00:00
#ifndef cmGlobalGenerator_h
#define cmGlobalGenerator_h
#include "cmStandardIncludes.h"
2006-02-23 15:07:24 +00:00
#include "cmTarget.h" // For cmTargets
#include "cmTargetDepend.h" // For cmTargetDependSet
#include "cmSystemTools.h" // for cmSystemTools::OutputOption
2002-08-30 20:00:35 +00:00
class cmake;
class cmGeneratorTarget;
2002-08-30 20:00:35 +00:00
class cmMakefile;
class cmLocalGenerator;
2007-06-15 20:07:16 +00:00
class cmExternalMakefileProjectGenerator;
2005-02-03 22:42:55 +00:00
class cmTarget;
class cmTargetExport;
class cmInstallTargetGenerator;
class cmInstallFilesGenerator;
2002-08-30 20:00:35 +00:00
/** \class cmGlobalGenerator
* \brief Responable for overseeing the generation process for the entire tree
*
* Subclasses of this class generate makefiles for various
* platforms.
*/
class cmGlobalGenerator
{
public:
///! Free any memory allocated with the GlobalGenerator
2002-09-04 19:24:49 +00:00
cmGlobalGenerator();
2002-08-30 20:00:35 +00:00
virtual ~cmGlobalGenerator();
2010-11-11 21:02:07 +00:00
2002-08-30 20:00:35 +00:00
///! Create a local generator appropriate to this Global Generator
virtual cmLocalGenerator *CreateLocalGenerator();
///! Get the name for this generator
virtual const char *GetName() const { return "Generic"; };
2010-11-11 21:02:07 +00:00
/** Get the documentation entry for this generator. */
virtual void GetDocumentation(cmDocumentationEntry& entry) const;
2010-11-11 21:02:07 +00:00
2002-08-30 20:00:35 +00:00
/**
* Create LocalGenerators and process the CMakeLists files. This does not
2010-11-11 21:02:07 +00:00
* actually produce any makefiles, DSPs, etc.
2002-08-30 20:00:35 +00:00
*/
virtual void Configure();
/**
* Generate the all required files for building this project/tree. This
* basically creates a series of LocalGenerators for each directory and
2010-11-11 21:02:07 +00:00
* requests that they Generate.
2002-08-30 20:00:35 +00:00
*/
virtual void Generate();
/**
2010-11-11 21:02:07 +00:00
* Set/Get and Clear the enabled languages.
2002-08-30 20:00:35 +00:00
*/
void SetLanguageEnabled(const char*, cmMakefile* mf);
bool GetLanguageEnabled(const char*) const;
2002-08-30 20:00:35 +00:00
void ClearEnabledLanguages();
void GetEnabledLanguages(std::vector<std::string>& lang);
2002-08-30 20:00:35 +00:00
/**
* Try to determine system infomation such as shared library
2010-11-11 21:02:07 +00:00
* extension, pthreads, byte order etc.
2002-08-30 20:00:35 +00:00
*/
2006-03-10 18:54:57 +00:00
virtual void EnableLanguage(std::vector<std::string>const& languages,
cmMakefile *, bool optional);
2002-08-30 20:00:35 +00: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);
2002-09-13 14:42:50 +00:00
/**
* Try to determine system infomation, get it from another generator
*/
virtual void EnableLanguagesFromGenerator(cmGlobalGenerator *gen,
cmMakefile* mf);
2002-09-13 14:42:50 +00:00
2002-08-30 20:00:35 +00:00
/**
2011-03-19 10:41:00 +00:00
* Try running cmake and building a file. This is used for dynamically
2002-08-30 20:00:35 +00:00
* loaded commands, not as part of the usual build process.
*/
virtual int TryCompile(const char *srcdir, const char *bindir,
const char *projectName, const char *targetName,
bool fast, std::string *output, cmMakefile* mf);
2002-08-30 20:00:35 +00:00
2010-11-11 21:02:07 +00: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.
*/
int Build(const char *srcdir, const char *bindir,
const char *projectName, const char *targetName,
std::string *output,
const char *makeProgram, const char *config,
bool clean, bool fast,
double timeout,
cmSystemTools::OutputOption outputflag=cmSystemTools::OUTPUT_NONE,
const char* extraOptions = 0,
std::vector<std::string> const& nativeOptions =
std::vector<std::string>());
2010-11-11 21:02:07 +00:00
virtual std::string GenerateBuildCommand(
const char* makeProgram,
2010-11-11 21:02:07 +00:00
const char *projectName, const char* additionalOptions,
const char *targetName,
const char* config, bool ignoreErrors, bool fast);
2010-11-11 21:02:07 +00:00
2002-08-30 20:00:35 +00:00
///! Set the CMake instance
void SetCMakeInstance(cmake *cm);
2010-11-11 21:02:07 +00:00
2002-08-30 20:00:35 +00:00
///! Get the CMake instance
2006-03-15 16:02:08 +00:00
cmake *GetCMakeInstance() { return this->CMakeInstance; };
2011-03-26 13:31:59 +00:00
const cmake *GetCMakeInstance() const { return this->CMakeInstance; };
2006-03-15 16:02:08 +00:00
void SetConfiguredFilesPath(cmGlobalGenerator* gen);
2010-11-11 21:02:07 +00:00
const std::vector<cmLocalGenerator *>& GetLocalGenerators() const {
return this->LocalGenerators;}
2002-08-30 20:00:35 +00:00
2010-11-11 21:02:07 +00:00
cmLocalGenerator* GetCurrentLocalGenerator()
{return this->CurrentLocalGenerator;}
2010-11-11 21:02:07 +00:00
void SetCurrentLocalGenerator(cmLocalGenerator* lg)
{this->CurrentLocalGenerator = lg;}
void AddLocalGenerator(cmLocalGenerator *lg);
///! Set an generator for an "external makefile based project"
void SetExternalMakefileProjectGenerator(
cmExternalMakefileProjectGenerator *extraGenerator);
2007-06-15 20:07:16 +00:00
const char* GetExtraGeneratorName() const;
void AddInstallComponent(const char* component);
2010-11-11 21:02:07 +00:00
const std::set<cmStdString>* GetInstallComponents() const
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 15:52:25 +00:00
{ return &InstallComponents; }
///! Add one installed target to the sets of the exports
2010-11-11 21:02:07 +00:00
void AddTargetToExports(const char* exportSet, cmTarget* target,
cmInstallTargetGenerator* archive,
cmInstallTargetGenerator* runTime,
cmInstallTargetGenerator* library,
cmInstallTargetGenerator* framework,
cmInstallTargetGenerator* bundle,
cmInstallFilesGenerator* publicHeaders);
///! Get the export target set with the given name
const std::vector<cmTargetExport*>* GetExportSet(const char* name) const;
/** Add a file to the manifest of generated targets for a configuration. */
void AddToManifest(const char* config, std::string const& f);
void EnableInstallTarget();
int TryCompileTimeout;
2010-11-11 21:02:07 +00:00
bool GetForceUnixPaths() const { return this->ForceUnixPaths; }
bool GetToolSupportsColor() const { return this->ToolSupportsColor; }
///! return the language for the given extension
const char* GetLanguageFromExtension(const char* ext);
///! is an extension to be ignored
bool IgnoreFile(const char* ext);
///! What is the preference for linkers and this language (None or Prefered)
int GetLinkerPreference(const char* lang);
///! What is the object file extension for a given source file?
const char* GetLanguageOutputExtension(cmSourceFile const&);
2006-02-24 22:35:35 +00:00
///! What is the configurations directory variable called?
virtual const char* GetCMakeCFGIntDir() const { return "."; }
2006-02-24 22:35:35 +00:00
/** 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 19:50:42 +00:00
/*
* Determine what program to use for building the project.
*/
void FindMakeProgram(cmMakefile*);
///! Find a target by name by searching the local generators.
cmTarget* FindTarget(const char* project, const char* name);
/** Determine if a name resolves to a framework on disk or a built target
that is a framework. */
bool NameResolvesToFramework(const std::string& libname);
/** If check to see if the target is linked to by any other
target in the project */
bool IsDependedOn(const char* project, cmTarget* target);
///! Find a local generator by its startdirectory
cmLocalGenerator* FindLocalGenerator(const char* start_dir);
/** 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 char* prefix,
const char* config,
const char* suffix,
std::string& dir);
/** Get the manifest of all targets that will be built for each
configuration. This is valid during generation only. */
cmTargetManifest const& GetTargetManifest() const
{ return this->TargetManifest; }
/** Get the content of a directory. Directory listings are loaded
from disk at most once and cached. During the generation step
the content will include the target files to be built even if
they do not yet exist. */
std::set<cmStdString> const& GetDirectoryContent(std::string const& dir,
bool needDisk = true);
void AddTarget(cmTarget* t);
virtual const char* GetAllTargetName() const { return "ALL_BUILD"; }
virtual const char* GetInstallTargetName() const { return "INSTALL"; }
virtual const char* GetInstallLocalTargetName() const { return 0; }
virtual const char* GetInstallStripTargetName() const { return 0; }
virtual const char* GetPreinstallTargetName() const { return 0; }
virtual const char* GetTestTargetName() const { return "RUN_TESTS"; }
virtual const char* GetPackageTargetName() const { return "PACKAGE"; }
virtual const char* GetPackageSourceTargetName() const { return 0; }
virtual const char* GetEditCacheTargetName() const { return 0; }
virtual const char* GetRebuildCacheTargetName() const { return 0; }
virtual const char* GetCleanTargetName() const { return 0; }
// 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(cmTarget & target);
/** Get per-target generator information. */
cmGeneratorTarget* GetGeneratorTarget(cmTarget*) const;
2007-07-20 12:36:16 +00:00
const std::map<cmStdString, 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 char* dir)
{
return this->BinaryDirectories.insert(dir).second;
2010-11-11 21:02:07 +00:00
}
/** Supported systems creates a GUID for the given name */
virtual void CreateGUID(const char*) {}
/** 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() { return false; }
/** Generate an <output>.rule file path for a given command output. */
virtual std::string GenerateRuleFile(std::string const& output) const;
2002-08-30 20:00:35 +00:00
protected:
typedef std::vector<cmLocalGenerator*> GeneratorVector;
// for a project collect all its targets by following depend
// information, and also collect all the targets
virtual void GetTargetSets(TargetDependSet& projectTargets,
TargetDependSet& originalTargets,
cmLocalGenerator* root, GeneratorVector const&);
virtual bool IsRootOnlyTarget(cmTarget* target);
void AddTargetDepends(cmTarget* target, TargetDependSet& projectTargets);
void SetLanguageEnabledFlag(const char* l, cmMakefile* mf);
void SetLanguageEnabledMaps(const char* l, cmMakefile* mf);
void FillExtensionToLanguageMap(const char* l, cmMakefile* mf);
virtual bool ComputeTargetDepends();
virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS();
bool CheckTargets();
void CreateAutomocTargets();
2010-11-11 21:02:07 +00:00
// Fill the ProjectMap, this must be called after LocalGenerators
2006-03-10 18:54:57 +00:00
// has been populated.
void FillProjectMap();
void CheckLocalGenerators();
bool IsExcluded(cmLocalGenerator* root, cmLocalGenerator* gen);
bool IsExcluded(cmLocalGenerator* root, cmTarget& target);
void FillLocalGeneratorToTargetMap();
2006-02-23 15:07:24 +00:00
void CreateDefaultGlobalTargets(cmTargets* targets);
cmTarget CreateGlobalTarget(const char* name, const char* message,
const cmCustomCommandLines* commandLines,
std::vector<std::string> depends, const char* workingDir);
2006-02-23 15:07:24 +00:00
bool NeedSymbolicMark;
bool UseLinkScript;
2006-03-15 16:02:08 +00:00
bool ForceUnixPaths;
bool ToolSupportsColor;
2006-03-15 16:02:08 +00:00
cmStdString FindMakeProgramFile;
cmStdString ConfiguredFilesPath;
cmake *CMakeInstance;
std::vector<cmLocalGenerator *> LocalGenerators;
cmLocalGenerator* CurrentLocalGenerator;
// map from project name to vector of local generators in that project
2006-03-15 16:02:08 +00:00
std::map<cmStdString, std::vector<cmLocalGenerator*> > ProjectMap;
2008-01-31 03:56:34 +00:00
std::map<cmLocalGenerator*, std::set<cmTarget *> >
LocalGeneratorToTargetMap;
2002-08-30 20:00:35 +00:00
// Set of named installation components requested by the project.
std::set<cmStdString> InstallComponents;
bool InstallTargetEnabled;
// Sets of named target exports
std::map<cmStdString, std::vector<cmTargetExport*> > ExportSets;
void ClearExportSets();
// Manifest of all targets that will be built for each configuration.
// This is computed just before local generators generate.
cmTargetManifest TargetManifest;
// All targets in the entire project.
std::map<cmStdString,cmTarget *> TotalTargets;
std::map<cmStdString,cmTarget *> ImportedTargets;
virtual const char* GetPredefinedTargetsFolder();
virtual bool UseFolderProperty();
2002-08-30 20:00:35 +00:00
private:
cmMakefile* TryCompileOuterMakefile;
float FirstTimeProgress;
// If you add a new map here, make sure it is copied
2010-11-11 21:02:07 +00:00
// in EnableLanguagesFromGenerator
2006-03-15 16:02:08 +00:00
std::map<cmStdString, bool> IgnoreExtensions;
std::map<cmStdString, bool> LanguageEnabled;
std::set<cmStdString> LanguagesReady; // Ready for try_compile
2006-03-15 16:02:08 +00:00
std::map<cmStdString, cmStdString> OutputExtensions;
std::map<cmStdString, cmStdString> LanguageToOutputExtension;
std::map<cmStdString, cmStdString> ExtensionToLanguage;
2010-11-11 21:02:07 +00:00
std::map<cmStdString, int> LanguageToLinkerPreference;
// Record hashes for rules and outputs.
struct RuleHash { char Data[32]; };
std::map<cmStdString, RuleHash> RuleHashes;
void CheckRuleHashes();
void CheckRuleHashes(std::string const& pfile, std::string const& home);
void WriteRuleHashes(std::string const& pfile);
void WriteSummary();
void WriteSummary(cmTarget* target);
cmExternalMakefileProjectGenerator* ExtraGenerator;
// track files replaced during a Generate
std::vector<std::string> FilesReplacedDuringGenerate;
// Store computed inter-target dependencies.
2008-01-31 03:56:34 +00:00
typedef std::map<cmTarget *, TargetDependSet> TargetDependMap;
TargetDependMap TargetDependencies;
// Per-target generator information.
typedef std::map<cmTarget*, cmGeneratorTarget*> GeneratorTargetsType;
GeneratorTargetsType GeneratorTargets;
void CreateGeneratorTargets();
void ClearGeneratorTargets();
virtual void ComputeTargetObjects(cmGeneratorTarget* gt) const;
// Cache directory content and target files to be built.
struct DirectoryContent: public std::set<cmStdString>
{
typedef std::set<cmStdString> derived;
bool LoadedFromDisk;
DirectoryContent(): LoadedFromDisk(false) {}
DirectoryContent(DirectoryContent const& dc):
derived(dc), LoadedFromDisk(dc.LoadedFromDisk) {}
};
std::map<cmStdString, DirectoryContent> DirectoryContentMap;
// Set of binary directories on disk.
std::set<cmStdString> BinaryDirectories;
2002-08-30 20:00:35 +00:00
};
#endif