CMake/Source/cmMakefile.h

1190 lines
38 KiB
C
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
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.
============================================================================*/
#ifndef cmMakefile_h
#define cmMakefile_h
2001-01-11 22:47:38 +03:00
#include "cmCacheManager.h"
#include "cmExecutionStatus.h"
#include "cmListFileCache.h"
#include "cmPolicies.h"
#include "cmPropertyMap.h"
#include "cmSystemTools.h"
#include "cmTarget.h"
#include "cmNewLineStyle.h"
#include "cmGeneratorTarget.h"
#include "cmExpandedCommandArgument.h"
2008-03-11 17:29:56 +03:00
#include "cmake.h"
2006-03-22 17:58:11 +03:00
#if defined(CMAKE_BUILD_WITH_CMAKE)
#include "cmSourceGroup.h"
#endif
#include <cmsys/auto_ptr.hxx>
#include <cmsys/RegularExpression.hxx>
#if defined(CMAKE_BUILD_WITH_CMAKE)
# include <cmsys/hash_map.hxx>
#endif
2001-04-20 01:39:03 +04:00
class cmFunctionBlocker;
2001-01-18 19:20:24 +03:00
class cmCommand;
class cmInstallGenerator;
2002-09-06 21:06:23 +04:00
class cmLocalGenerator;
class cmMakeDepend;
class cmSourceFile;
class cmTest;
class cmTestGenerator;
2003-01-08 20:59:52 +03:00
class cmVariableWatch;
class cmake;
class cmMakefileCall;
class cmCMakePolicyCommand;
2001-01-11 22:47:38 +03:00
/** \class cmMakefile
* \brief Process the input CMakeLists.txt file.
*
* Process and store into memory the input CMakeLists.txt file.
2001-01-18 19:20:24 +03:00
* Each CMakeLists.txt file is parsed and the commands found there
2001-01-11 22:47:38 +03:00
* are added into the build process.
*/
class cmMakefile
{
class Internals;
cmsys::auto_ptr<Internals> Internal;
public:
/**
* Return the major and minor version of the cmake that
* was used to write the currently loaded cache, note
* this method will not work before the cache is loaded.
*/
unsigned int GetCacheMajorVersion() const;
unsigned int GetCacheMinorVersion() const;
/* Check for unused variables in this scope */
void CheckForUnusedVariables() const;
/* Mark a variable as used */
void MarkVariableAsUsed(const std::string& var);
/* return true if a variable has been initialized */
bool VariableInitialized(const std::string& ) const;
2010-08-25 00:50:15 +04:00
/* return true if a variable has been used */
bool VariableUsed(const std::string& ) const;
/** Return whether compatibility features needed for a version of
the cache or lower should be enabled. */
bool NeedCacheCompatibility(int major, int minor) const;
2011-10-13 21:51:18 +04:00
2001-01-11 22:47:38 +03:00
/**
* Construct an empty makefile.
*/
2002-08-24 00:13:34 +04:00
cmMakefile();
cmMakefile(const cmMakefile& mf);
2001-01-11 22:47:38 +03:00
/**
* Destructor.
*/
2002-08-24 00:13:34 +04:00
~cmMakefile();
2001-01-11 22:47:38 +03:00
/**
* Read and parse a CMakeLists.txt file.
*/
2011-10-13 21:51:18 +04:00
bool ReadListFile(const char* listfile,
const char* external= 0,
std::string* fullPath= 0,
bool noPolicyScope = true);
2001-01-11 22:47:38 +03:00
2001-04-20 01:39:03 +04:00
/**
* Add a function blocker to this makefile
*/
void AddFunctionBlocker(cmFunctionBlocker* fb);
/**
* Remove the function blocker whose scope ends with the given command.
* This returns ownership of the function blocker object.
*/
cmsys::auto_ptr<cmFunctionBlocker>
RemoveFunctionBlocker(cmFunctionBlocker* fb, const cmListFileFunction& lff);
/** Push/pop a lexical (function blocker) barrier automatically. */
class LexicalPushPop
{
public:
LexicalPushPop(cmMakefile* mf);
~LexicalPushPop();
void Quiet() { this->ReportError = false; }
private:
cmMakefile* Makefile;
bool ReportError;
};
friend class LexicalPushPop;
/**
* Try running cmake and building a file. This is used for dynalically
* loaded commands, not as part of the usual build process.
*/
2014-02-25 02:38:30 +04:00
int TryCompile(const std::string& srcdir, const std::string& bindir,
const std::string& projectName, const std::string& targetName,
bool fast,
const std::vector<std::string> *cmakeArgs,
std::string& output);
2011-10-13 21:51:18 +04:00
bool GetIsSourceFileTryCompile() const;
2001-01-11 22:47:38 +03:00
/**
* Specify the makefile generator. This is platform/compiler
* dependent, although the interface is through a generic
* superclass.
*/
2002-09-06 21:06:23 +04:00
void SetLocalGenerator(cmLocalGenerator*);
2011-10-13 21:51:18 +04:00
///! Get the current makefile generator.
2014-01-22 17:38:10 +04:00
cmLocalGenerator* GetLocalGenerator() const
2006-03-15 19:02:08 +03:00
{ return this->LocalGenerator;}
2001-01-11 22:47:38 +03:00
/**
* Help enforce global target name uniqueness.
*/
bool EnforceUniqueName(std::string const& name, std::string& msg,
bool isCustom = false) const;
2001-01-11 22:47:38 +03:00
/**
* Perform FinalPass, Library dependency analysis etc before output of the
2011-10-13 21:51:18 +04:00
* makefile.
2001-01-11 22:47:38 +03:00
*/
void ConfigureFinalPass();
2011-10-13 21:51:18 +04:00
/**
* run the final pass on all commands.
*/
void FinalPass();
2011-10-13 21:51:18 +04:00
2001-01-11 22:47:38 +03:00
/**
* Print the object state to std::cout.
*/
void Print() const;
/** Add a custom command to the build. */
2014-02-07 02:31:47 +04:00
void AddCustomCommandToTarget(const std::string& target,
const std::vector<std::string>& depends,
const cmCustomCommandLines& commandLines,
cmTarget::CustomCommandType type,
const char* comment, const char* workingDir,
bool escapeOldStyle = true) const;
cmSourceFile* AddCustomCommandToOutput(
const std::vector<std::string>& outputs,
const std::vector<std::string>& depends,
const std::string& main_dependency,
const cmCustomCommandLines& commandLines,
const char* comment, const char* workingDir,
bool replace = false,
bool escapeOldStyle = true);
cmSourceFile* AddCustomCommandToOutput(
const std::string& output,
const std::vector<std::string>& depends,
const std::string& main_dependency,
const cmCustomCommandLines& commandLines,
const char* comment, const char* workingDir,
bool replace = false,
bool escapeOldStyle = true);
2014-02-07 02:31:47 +04:00
void AddCustomCommandOldStyle(const std::string& target,
const std::vector<std::string>& outputs,
const std::vector<std::string>& depends,
const std::string& source,
const cmCustomCommandLines& commandLines,
const char* comment);
2001-01-11 22:47:38 +03:00
/**
* Add a define flag to the build.
*/
void AddDefineFlag(const char* definition);
void RemoveDefineFlag(const char* definition);
void AddCompileOption(const char* option);
2001-01-11 22:47:38 +03:00
/** Create a new imported target with the name and type given. */
2014-02-07 02:31:47 +04:00
cmTarget* AddImportedTarget(const std::string& name,
cmTarget::TargetType type,
bool global);
2014-02-07 02:31:47 +04:00
cmTarget* AddNewTarget(cmTarget::TargetType type, const std::string& name);
2011-10-13 21:51:18 +04:00
2001-01-11 22:47:38 +03:00
/**
* Add an executable to the build.
*/
2011-10-13 21:51:18 +04:00
cmTarget* AddExecutable(const char *exename,
const std::vector<std::string> &srcs,
2007-03-12 17:26:59 +03:00
bool excludeFromAll = false);
2001-01-11 22:47:38 +03:00
/**
* Add a utility to the build. A utiltity target is a command that
* is run every time the target is built.
*/
void AddUtilityCommand(const std::string& utilityName, bool excludeFromAll,
const std::vector<std::string>& depends,
2006-02-08 18:58:36 +03:00
const char* workingDirectory,
const char* command,
const char* arg1=0,
const char* arg2=0,
2005-06-17 00:33:24 +04:00
const char* arg3=0,
const char* arg4=0);
cmTarget* AddUtilityCommand(const std::string& utilityName,
bool excludeFromAll,
const char* workingDirectory,
const std::vector<std::string>& depends,
const cmCustomCommandLines& commandLines,
bool escapeOldStyle = true,
const char* comment = 0);
2001-01-11 22:47:38 +03:00
/**
* Add a link library to the build.
*/
2014-02-07 02:31:47 +04:00
void AddLinkLibrary(const std::string&);
void AddLinkLibrary(const std::string&, cmTarget::LinkLibraryType type);
void AddLinkLibraryForTarget(const std::string& tgt, const std::string&,
cmTarget::LinkLibraryType type);
2014-02-07 02:31:47 +04:00
void AddLinkDirectoryForTarget(const std::string& tgt, const std::string& d);
2001-01-11 22:47:38 +03:00
/**
* Add a link directory to the build.
*/
2014-02-07 02:31:47 +04:00
void AddLinkDirectory(const std::string&);
2001-01-11 22:47:38 +03:00
const std::vector<std::string>& GetLinkDirectories() const
{
2006-03-15 19:02:08 +03:00
return this->LinkDirectories;
}
void SetLinkDirectories(const std::vector<std::string>& vec)
{
2006-03-15 19:02:08 +03:00
this->LinkDirectories = vec;
}
2001-01-11 22:47:38 +03:00
/**
* Add a subdirectory to the build.
*/
void AddSubDirectory(const std::string&, bool excludeFromAll=false,
2006-03-10 19:13:15 +03:00
bool preorder = false);
void AddSubDirectory(const std::string& fullSrcDir,
const std::string& fullBinDir,
2007-03-12 17:26:59 +03:00
bool excludeFromAll, bool preorder,
bool immediate);
2001-01-11 22:47:38 +03:00
/**
* Configure a subdirectory
*/
void ConfigureSubDirectory(cmLocalGenerator *);
2011-10-13 21:51:18 +04:00
2001-01-11 22:47:38 +03:00
/**
* Add an include directory to the build.
*/
void AddIncludeDirectories(const std::vector<std::string> &incs,
bool before = false);
2001-01-11 22:47:38 +03:00
/**
* Add a variable definition to the build. This variable
* can be used in CMake to refer to lists, directories, etc.
*/
void AddDefinition(const std::string& name, const char* value);
///! Add a definition to this makefile and the global cmake cache.
void AddCacheDefinition(const std::string& name, const char* value,
const char* doc,
2008-11-22 00:32:39 +03:00
cmCacheManager::CacheEntryType type,
bool force = false);
2001-01-11 22:47:38 +03:00
2001-04-24 20:40:37 +04:00
/**
2011-10-13 21:51:18 +04:00
* Add bool variable definition to the build.
2001-04-24 20:40:37 +04:00
*/
void AddDefinition(const std::string& name, bool);
2001-04-24 20:40:37 +04:00
2002-09-18 18:39:41 +04:00
/**
* Remove a variable definition from the build. This is not valid
* for cache entries, and will only affect the current makefile.
*/
void RemoveDefinition(const std::string& name);
///! Remove a definition from the cache.
void RemoveCacheDefinition(const std::string& name);
2011-10-13 21:51:18 +04:00
2001-01-11 22:47:38 +03:00
/**
* Specify the name of the project for this build.
*/
void SetProjectName(const char*);
2001-01-11 22:47:38 +03:00
/**
* Get the name of the project for this build.
*/
2007-06-21 07:01:36 +04:00
const char* GetProjectName() const
2001-01-11 22:47:38 +03:00
{
2006-03-15 19:02:08 +03:00
return this->ProjectName.c_str();
2001-01-11 22:47:38 +03:00
}
/** Get the configurations to be generated. */
std::string GetConfigurations(std::vector<std::string>& configs,
bool single = true) const;
2001-01-11 22:47:38 +03:00
/**
* Set the name of the library.
*/
2014-02-07 02:31:47 +04:00
cmTarget* AddLibrary(const std::string& libname, cmTarget::TargetType type,
const std::vector<std::string> &srcs,
2007-03-12 17:26:59 +03:00
bool excludeFromAll = false);
2014-02-07 02:31:47 +04:00
void AddAlias(const std::string& libname, cmTarget *tgt);
2001-01-11 22:47:38 +03:00
2006-03-22 17:58:11 +03:00
#if defined(CMAKE_BUILD_WITH_CMAKE)
/**
* Add a root source group for consideration when adding a new source.
*/
void AddSourceGroup(const std::string& name, const char* regex=0);
/**
* Add a source group for consideration when adding a new source.
* name is tokenized.
*/
2011-10-13 21:51:18 +04:00
void AddSourceGroup(const std::vector<std::string>& name,
const char* regex=0);
2006-03-22 17:58:11 +03:00
#endif
//@{
/**
2011-10-13 21:51:18 +04:00
* Set, Push, Pop policy values for CMake.
*/
bool SetPolicy(cmPolicies::PolicyID id, cmPolicies::PolicyStatus status);
bool SetPolicy(const char *id, cmPolicies::PolicyStatus status);
cmPolicies::PolicyStatus GetPolicyStatus(cmPolicies::PolicyID id) const;
bool SetPolicyVersion(const char *version);
void RecordPolicies(cmPolicies::PolicyMap& pm);
//@}
/** Helper class to push and pop policies automatically. */
class PolicyPushPop
{
public:
PolicyPushPop(cmMakefile* m,
bool weak = false,
cmPolicies::PolicyMap const& pm = cmPolicies::PolicyMap());
~PolicyPushPop();
void Quiet() { this->ReportError = false; }
private:
cmMakefile* Makefile;
bool ReportError;
};
friend class PolicyPushPop;
/**
* Get the Policies Instance
*/
cmPolicies *GetPolicies() const;
struct cmCMP0054Id
{
cmCMP0054Id(cmListFileContext const& context):
Context(context)
{
}
bool operator< (cmCMP0054Id const& id) const
{
if(this->Context.FilePath != id.Context.FilePath)
return this->Context.FilePath < id.Context.FilePath;
return this->Context.Line < id.Context.Line;
}
cmListFileContext Context;
};
mutable std::set<cmCMP0054Id> CMP0054ReportedIds;
/**
* Determine if the given context, name pair has already been reported
* in context of CMP0054.
*/
bool HasCMP0054AlreadyBeenReported(
cmListFileContext context) const;
2011-10-13 21:51:18 +04:00
2001-01-11 22:47:38 +03:00
/**
* Add an auxiliary directory to the build.
*/
void AddExtraDirectory(const char* dir);
2011-10-13 21:51:18 +04:00
2001-02-15 21:30:13 +03:00
/**
* Add an auxiliary directory to the build.
*/
void MakeStartDirectoriesCurrent()
{
2011-10-13 21:51:18 +04:00
this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR",
2006-03-15 19:02:08 +03:00
this->cmStartDirectory.c_str());
2011-10-13 21:51:18 +04:00
this->AddDefinition("CMAKE_CURRENT_BINARY_DIR",
2006-03-15 19:02:08 +03:00
this->StartOutputDirectory.c_str());
2001-02-15 21:30:13 +03:00
}
2011-10-13 21:51:18 +04:00
2001-02-15 21:30:13 +03:00
//@{
2001-01-11 22:47:38 +03:00
/**
2001-02-15 21:30:13 +03:00
* Set/Get the home directory (or output directory) in the project. The
* home directory is the top directory of the project. It is where
* CMakeSetup or configure was run. Remember that CMake processes
* CMakeLists files by recursing up the tree starting at the StartDirectory
2011-10-13 21:51:18 +04:00
* and going up until it reaches the HomeDirectory.
2001-01-11 22:47:38 +03:00
*/
void SetHomeDirectory(const std::string& dir);
2001-04-25 00:49:12 +04:00
const char* GetHomeDirectory() const
{
2006-03-15 19:02:08 +03:00
return this->cmHomeDirectory.c_str();
}
void SetHomeOutputDirectory(const std::string& lib);
2001-04-25 00:49:12 +04:00
const char* GetHomeOutputDirectory() const
{
2006-03-15 19:02:08 +03:00
return this->HomeOutputDirectory.c_str();
}
2001-02-15 21:30:13 +03:00
//@}
/**
* Set CMAKE_SCRIPT_MODE_FILE variable when running a -P script.
*/
void SetScriptModeFile(const char* scriptfile);
/**
* Set CMAKE_ARGC, CMAKE_ARGV0 ... variables.
*/
void SetArgcArgv(const std::vector<std::string>& args);
2001-02-15 21:30:13 +03:00
//@{
2001-01-11 22:47:38 +03:00
/**
2001-02-15 21:30:13 +03:00
* Set/Get the start directory (or output directory). The start directory
* is the directory of the CMakeLists.txt file that started the current
* round of processing. Remember that CMake processes CMakeLists files by
* recursing up the tree starting at the StartDirectory and going up until
2011-10-13 21:51:18 +04:00
* it reaches the HomeDirectory.
2001-01-11 22:47:38 +03:00
*/
void SetStartDirectory(const std::string& dir)
{
2006-03-15 19:02:08 +03:00
this->cmStartDirectory = dir;
cmSystemTools::ConvertToUnixSlashes(this->cmStartDirectory);
2011-10-13 21:51:18 +04:00
this->cmStartDirectory =
2006-04-20 23:49:56 +04:00
cmSystemTools::CollapseFullPath(this->cmStartDirectory.c_str());
2011-10-13 21:51:18 +04:00
this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR",
2006-03-15 19:02:08 +03:00
this->cmStartDirectory.c_str());
}
2001-04-25 00:49:12 +04:00
const char* GetStartDirectory() const
{
2006-03-15 19:02:08 +03:00
return this->cmStartDirectory.c_str();
}
void SetStartOutputDirectory(const std::string& lib)
2001-02-15 21:30:13 +03:00
{
2006-03-15 19:02:08 +03:00
this->StartOutputDirectory = lib;
cmSystemTools::ConvertToUnixSlashes(this->StartOutputDirectory);
2011-10-13 21:51:18 +04:00
this->StartOutputDirectory =
2006-04-20 23:49:56 +04:00
cmSystemTools::CollapseFullPath(this->StartOutputDirectory.c_str());
2006-03-15 19:02:08 +03:00
cmSystemTools::MakeDirectory(this->StartOutputDirectory.c_str());
2011-10-13 21:51:18 +04:00
this->AddDefinition("CMAKE_CURRENT_BINARY_DIR",
2006-03-15 19:02:08 +03:00
this->StartOutputDirectory.c_str());
2001-02-15 21:30:13 +03:00
}
2001-04-25 00:49:12 +04:00
const char* GetStartOutputDirectory() const
{
2006-03-15 19:02:08 +03:00
return this->StartOutputDirectory.c_str();
}
2001-02-15 21:30:13 +03:00
//@}
2001-01-11 22:47:38 +03:00
2011-10-13 21:51:18 +04:00
const char* GetCurrentDirectory() const
2001-02-15 21:30:13 +03:00
{
2006-03-15 19:02:08 +03:00
return this->cmStartDirectory.c_str();
2001-02-15 21:30:13 +03:00
}
2001-04-25 00:49:12 +04:00
const char* GetCurrentOutputDirectory() const
2001-02-15 21:30:13 +03:00
{
2006-03-15 19:02:08 +03:00
return this->StartOutputDirectory.c_str();
2001-02-15 21:30:13 +03:00
}
2001-04-30 18:52:58 +04:00
/* Get the current CMakeLists.txt file that is being processed. This
* is just used in order to be able to 'branch' from one file to a second
* transparently */
const char* GetCurrentListFile() const
{
2006-03-15 19:02:08 +03:00
return this->cmCurrentListFile.c_str();
2001-04-30 18:52:58 +04:00
}
2001-02-15 21:30:13 +03:00
//@}
2011-10-13 21:51:18 +04:00
/**
* Set a regular expression that include files must match
* in order to be considered as part of the depend information.
*/
void SetIncludeRegularExpression(const char* regex)
{
2006-03-15 19:02:08 +03:00
this->IncludeFileRegularExpression = regex;
}
2014-01-22 17:38:10 +04:00
const char* GetIncludeRegularExpression() const
2011-10-13 21:51:18 +04:00
{
2006-03-15 19:02:08 +03:00
return this->IncludeFileRegularExpression.c_str();
}
2011-10-13 21:51:18 +04:00
/**
* Set a regular expression that include files that are not found
* must match in order to be considered a problem.
*/
void SetComplainRegularExpression(const std::string& regex)
{
2006-03-15 19:02:08 +03:00
this->ComplainFileRegularExpression = regex;
}
const char* GetComplainRegularExpression() const
{
2006-03-15 19:02:08 +03:00
return this->ComplainFileRegularExpression.c_str();
}
2001-01-11 22:47:38 +03:00
/**
* Get the list of targets
2001-01-11 22:47:38 +03:00
*/
2006-03-15 19:02:08 +03:00
cmTargets &GetTargets() { return this->Targets; }
/**
* Get the list of targets, const version
*/
const cmTargets &GetTargets() const { return this->Targets; }
const std::vector<cmTarget*> &GetOwnedImportedTargets() const
{
return this->ImportedTargetsOwned;
}
2001-01-11 22:47:38 +03:00
const cmGeneratorTargetsType &GetGeneratorTargets() const
{
return this->GeneratorTargets;
}
void SetGeneratorTargets(const cmGeneratorTargetsType &targets)
{
this->GeneratorTargets = targets;
}
cmTarget* FindTarget(const std::string& name,
bool excludeAliases = false) const;
2001-01-11 22:47:38 +03:00
/** Find a target to use in place of the given name. The target
returned may be imported or built within the project. */
cmTarget* FindTargetToUse(const std::string& name,
bool excludeAliases = false) const;
bool IsAlias(const std::string& name) const;
2014-02-07 02:31:47 +04:00
cmGeneratorTarget* FindGeneratorTargetToUse(const std::string& name) const;
2006-04-11 20:51:20 +04:00
/**
* Mark include directories as system directories.
*/
void AddSystemIncludeDirectories(const std::set<std::string> &incs);
/** Expand out any arguements in the vector that have ; separated
2011-10-13 21:51:18 +04:00
* strings into multiple arguements. A new vector is created
* containing the expanded versions of all arguments in argsIn.
* This method differes from the one in cmSystemTools in that if
* the CmakeLists file is version 1.2 or earlier it will check for
* source lists being used without ${} around them
2001-01-11 22:47:38 +03:00
*/
void ExpandSourceListArguments(std::vector<std::string> const& argsIn,
std::vector<std::string>& argsOut,
unsigned int startArgumentIndex) const;
/** Get a cmSourceFile pointer for a given source name, if the name is
* not found, then a null pointer is returned.
*/
cmSourceFile* GetSource(const std::string& sourceName) const;
2003-06-03 18:30:23 +04:00
/** Create the source file and return it. generated
* indicates if it is a generated file, this is used in determining
* how to create the source file instance e.g. name
*/
cmSourceFile* CreateSource(const std::string& sourceName,
bool generated = false);
2003-06-03 18:30:23 +04:00
/** Get a cmSourceFile pointer for a given source name, if the name is
2011-10-13 21:51:18 +04:00
* not found, then create the source file and return it. generated
2003-06-03 18:30:23 +04:00
* indicates if it is a generated file, this is used in determining
* how to create the source file instance e.g. name
*/
cmSourceFile* GetOrCreateSource(const std::string& sourceName,
2003-06-03 18:30:23 +04:00
bool generated = false);
2001-01-11 22:47:38 +03:00
/**
* Obtain a list of auxiliary source directories.
*/
const std::vector<std::string>& GetAuxSourceDirectories() const
2006-03-15 19:02:08 +03:00
{return this->AuxSourceDirectories;}
//@{
/**
* Return a list of extensions associated with source and header
* files
*/
const std::vector<std::string>& GetSourceExtensions() const
2006-03-15 19:02:08 +03:00
{return this->SourceFileExtensions;}
const std::vector<std::string>& GetHeaderExtensions() const
2006-03-15 19:02:08 +03:00
{return this->HeaderFileExtensions;}
//@}
2001-01-11 22:47:38 +03:00
/**
* Given a variable name, return its value (as a string).
* If the variable is not found in this makefile instance, the
* cache is then queried.
*/
const char* GetDefinition(const std::string&) const;
const char* GetSafeDefinition(const std::string&) const;
const char* GetRequiredDefinition(const std::string& name) const;
bool IsDefinitionSet(const std::string&) const;
/**
* Get the list of all variables in the current space. If argument
* cacheonly is specified and is greater than 0, then only cache
* variables will be listed.
*/
std::vector<std::string> GetDefinitions(int cacheonly=0) const;
2011-10-13 21:51:18 +04:00
/**
* Test a boolean variable to see if it is true or false.
* If the variable is not found in this makefile instance, the
* cache is then queried.
* Returns false if no entry defined.
*/
bool IsOn(const std::string& name) const;
bool IsSet(const std::string& name) const;
2001-01-11 22:47:38 +03:00
/** Return whether the target platform is 64-bit. */
bool PlatformIs64Bit() const;
Support building shared libraries or modules without soname (#13155) Add a boolean target property NO_SONAME which may be used to disable soname for the specified shared library or module even if the platform supports it. This property should be useful for private shared libraries or various plugins which live in private directories and have not been designed to be found or loaded globally. Replace references to <CMAKE_SHARED_LIBRARY_SONAME_${LANG}_FLAG> and hard-coded -install_name flags with a conditional <SONAME_FLAG> which is expanded to the value of the CMAKE_SHARED_LIBRARY_SONAME_${LANG}_FLAG definition as long as soname supports is enabled for the target in question. Keep expanding CMAKE_SHARED_LIBRARY_SONAME_${LANG}_FLAG in rules in case third party projects still use it. Such projects would not yet use NO_SONAME so the adjacent <TARGET_SONAME> will always be expanded. Make <TARGET_INSTALLNAME_DIR> NO_SONAME aware as well. Since -install_name is soname on OS X, this should not be a problem if this variable is expanded only if soname is enabled. The Ninja generator performs rule variable substitution only once globally per rule to put its own placeholders. Final substitution is performed by ninja at build time. Therefore we cannot conditionally replace the soname placeholders on a per-target basis. Rather than omitting $SONAME from rules.ninja, simply do not write its contents for targets which have NO_SONAME. Since 3 variables are affected by NO_SONAME ($SONAME, $SONAME_FLAG, $INSTALLNAME_DIR), set them only if soname is enabled.
2012-04-22 17:42:55 +04:00
/** Retrieve soname flag for the specified language if supported */
const char* GetSONameFlag(const std::string& language) const;
Support building shared libraries or modules without soname (#13155) Add a boolean target property NO_SONAME which may be used to disable soname for the specified shared library or module even if the platform supports it. This property should be useful for private shared libraries or various plugins which live in private directories and have not been designed to be found or loaded globally. Replace references to <CMAKE_SHARED_LIBRARY_SONAME_${LANG}_FLAG> and hard-coded -install_name flags with a conditional <SONAME_FLAG> which is expanded to the value of the CMAKE_SHARED_LIBRARY_SONAME_${LANG}_FLAG definition as long as soname supports is enabled for the target in question. Keep expanding CMAKE_SHARED_LIBRARY_SONAME_${LANG}_FLAG in rules in case third party projects still use it. Such projects would not yet use NO_SONAME so the adjacent <TARGET_SONAME> will always be expanded. Make <TARGET_INSTALLNAME_DIR> NO_SONAME aware as well. Since -install_name is soname on OS X, this should not be a problem if this variable is expanded only if soname is enabled. The Ninja generator performs rule variable substitution only once globally per rule to put its own placeholders. Final substitution is performed by ninja at build time. Therefore we cannot conditionally replace the soname placeholders on a per-target basis. Rather than omitting $SONAME from rules.ninja, simply do not write its contents for targets which have NO_SONAME. Since 3 variables are affected by NO_SONAME ($SONAME, $SONAME_FLAG, $INSTALLNAME_DIR), set them only if soname is enabled.
2012-04-22 17:42:55 +04:00
/**
2001-01-11 22:47:38 +03:00
* Get a list of preprocessor define flags.
*/
const char* GetDefineFlags() const
2006-03-15 19:02:08 +03:00
{return this->DefineFlags.c_str();}
/**
* Make sure CMake can write this file
*/
bool CanIWriteThisFile(const char* fileName) const;
2011-10-13 21:51:18 +04:00
2006-03-22 17:58:11 +03:00
#if defined(CMAKE_BUILD_WITH_CMAKE)
/**
* Get the vector source groups.
*/
const std::vector<cmSourceGroup>& GetSourceGroups() const
2006-03-15 19:02:08 +03:00
{ return this->SourceGroups; }
2001-04-30 18:52:58 +04:00
2002-10-05 02:16:13 +04:00
/**
* Get the source group
*/
cmSourceGroup* GetSourceGroup(const std::vector<std::string>&name) const;
2006-03-22 17:58:11 +03:00
#endif
2002-10-05 02:16:13 +04:00
2001-04-30 18:52:58 +04:00
/**
* Get the vector of list files on which this makefile depends
*/
const std::vector<std::string>& GetListFiles() const
2006-03-15 19:02:08 +03:00
{ return this->ListFiles; }
///! When the file changes cmake will be re-run from the build system.
void AddCMakeDependFile(const std::string& file)
2006-03-15 19:02:08 +03:00
{ this->ListFiles.push_back(file);}
void AddCMakeDependFilesFromUser();
std::string GetListFileStack() const;
/**
* Get the current context backtrace.
*/
cmListFileBacktrace GetBacktrace() const;
/**
* Get the vector of files created by this makefile
*/
const std::vector<std::string>& GetOutputFiles() const
{ return this->OutputFiles; }
void AddCMakeOutputFile(const std::string& file)
{ this->OutputFiles.push_back(file);}
2011-10-13 21:51:18 +04:00
/**
2011-10-13 21:51:18 +04:00
* Expand all defined variables in the string.
2006-03-15 19:02:08 +03:00
* Defined variables come from the this->Definitions map.
* They are expanded with ${var} where var is the
2011-03-20 16:22:39 +03:00
* entry in the this->Definitions map. Also \@var\@ is
* expanded to match autoconf style expansions.
*/
const char *ExpandVariablesInString(std::string& source) const;
const char *ExpandVariablesInString(std::string& source, bool escapeQuotes,
bool noEscapes,
bool atOnly = false,
const char* filename = 0,
2005-04-12 21:27:07 +04:00
long line = -1,
bool removeEmpty = false,
bool replaceAt = false) const;
/**
* Remove any remaining variables in the string. Anything with ${var} or
2011-03-20 16:22:39 +03:00
* \@var\@ will be removed.
*/
2011-10-13 21:51:18 +04:00
void RemoveVariablesInString(std::string& source,
2006-05-12 20:29:09 +04:00
bool atOnly = false) const;
/**
* Expand variables in the makefiles ivars such as link directories etc
*/
void ExpandVariablesCMP0019();
/**
* Replace variables and #cmakedefine lines in the given string.
* See cmConfigureFileCommand for details.
*/
void ConfigureString(const std::string& input, std::string& output,
bool atOnly, bool escapeQuotes) const;
2004-03-09 15:50:45 +03:00
/**
* Copy file but change lines acording to ConfigureString
*/
2011-10-13 21:51:18 +04:00
int ConfigureFile(const char* infile, const char* outfile,
bool copyonly, bool atOnly, bool escapeQuotes,
const cmNewLineStyle& = cmNewLineStyle());
2004-03-09 15:50:45 +03:00
2006-03-22 17:58:11 +03:00
#if defined(CMAKE_BUILD_WITH_CMAKE)
/**
* find what source group this source is in
*/
cmSourceGroup* FindSourceGroup(const char* source,
std::vector<cmSourceGroup> &groups) const;
2006-03-22 17:58:11 +03:00
#endif
/**
* Print a command's invocation
*/
void PrintCommandTrace(const cmListFileFunction& lff) const;
2001-07-26 00:53:13 +04:00
/**
* Execute a single CMake command. Returns true if the command
* succeeded or false if it failed.
2001-07-26 00:53:13 +04:00
*/
2011-10-13 21:51:18 +04:00
bool ExecuteCommand(const cmListFileFunction& lff,
cmExecutionStatus &status);
/** Check if a command exists. */
bool CommandExists(const char* name) const;
2011-10-13 21:51:18 +04:00
/**
* Add a command to this cmake instance
*/
void AddCommand(cmCommand* );
2006-05-12 20:29:09 +04:00
///! Enable support for named language, if nil then all languages are
///enabled.
void EnableLanguage(std::vector<std::string>const& languages, bool optional);
/**
* Set/Get the name of the parent directories CMakeLists file
* given a current CMakeLists file name
*/
2002-09-06 21:06:23 +04:00
cmCacheManager *GetCacheManager() const;
/**
* Get the variable watch. This is used to determine when certain variables
* are accessed.
*/
#ifdef CMAKE_BUILD_WITH_CMAKE
2003-01-08 20:59:52 +03:00
cmVariableWatch* GetVariableWatch() const;
#endif
///! Display progress or status message.
void DisplayStatus(const char*, float) const;
2011-10-13 21:51:18 +04:00
/**
* Expand the given list file arguments into the full set after
* variable replacement and list expansion.
*/
bool ExpandArguments(std::vector<cmListFileArgument> const& inArgs,
std::vector<std::string>& outArgs) const;
bool ExpandArguments(std::vector<cmListFileArgument> const& inArgs,
std::vector<cmExpandedCommandArgument>& outArgs) const;
/**
* Get the instance
2011-10-13 21:51:18 +04:00
*/
cmake *GetCMakeInstance() const;
2003-06-03 18:30:23 +04:00
/**
* Get all the source files this makefile knows about
*/
2011-10-13 21:51:18 +04:00
const std::vector<cmSourceFile*> &GetSourceFiles() const
2006-03-15 19:02:08 +03:00
{return this->SourceFiles;}
std::vector<cmSourceFile*> &GetSourceFiles() {return this->SourceFiles;}
2003-06-03 18:30:23 +04:00
/**
* Is there a source file that has the provided source file as an output?
* if so then return it
*/
cmSourceFile *GetSourceFileWithOutput(const std::string& outName) const;
/**
* Add a macro to the list of macros. The arguments should be name of the
2011-10-13 21:51:18 +04:00
* macro and a documentation signature of it
*/
void AddMacro(const char* name, const char* signature);
///! Add a new cmTest to the list of tests for this makefile.
2014-02-04 06:20:33 +04:00
cmTest* CreateTest(const std::string& testName);
/** Get a cmTest pointer for a given test name, if the name is
* not found, then a null pointer is returned.
*/
2014-02-04 06:20:33 +04:00
cmTest* GetTest(const std::string& testName) const;
/**
* Get a list of macros as a ; separated string
*/
2014-01-22 17:38:10 +04:00
void GetListOfMacros(std::string& macros) const;
/**
* Return a location of a file in cmake or custom modules directory
*/
std::string GetModulesFile(const char* name) const;
2011-10-13 21:51:18 +04:00
///! Set/Get a property of this directory
void SetProperty(const std::string& prop, const char *value);
void AppendProperty(const std::string& prop, const char *value,
bool asString=false);
const char *GetProperty(const std::string& prop) const;
const char *GetProperty(const std::string& prop,
cmProperty::ScopeType scope) const;
bool GetPropertyAsBool(const std::string& prop) const;
const char* GetFeature(const std::string& feature,
const std::string& config);
// Get the properties
cmPropertyMap &GetProperties() { return this->Properties; }
///! Initialize a makefile from its parent
void InitializeFromParent();
2011-10-13 21:51:18 +04:00
///! Set/Get the preorder flag
void SetPreOrder(bool p) { this->PreOrder = p; }
2007-06-16 00:07:16 +04:00
bool GetPreOrder() const { return this->PreOrder; }
void AddInstallGenerator(cmInstallGenerator* g)
2007-06-16 00:07:16 +04:00
{ if(g) this->InstallGenerators.push_back(g); }
std::vector<cmInstallGenerator*>& GetInstallGenerators()
2006-03-15 19:02:08 +03:00
{ return this->InstallGenerators; }
void AddTestGenerator(cmTestGenerator* g)
{ if(g) this->TestGenerators.push_back(g); }
const std::vector<cmTestGenerator*>& GetTestGenerators() const
{ return this->TestGenerators; }
// Define the properties
static void DefineProperties(cmake *cm);
2007-12-03 21:35:41 +03:00
// push and pop variable scopes
void PushScope();
void PopScope();
void RaiseScope(const std::string& var, const char *value);
2007-12-03 21:35:41 +03:00
/** Helper class to push and pop scopes automatically. */
class ScopePushPop
{
public:
ScopePushPop(cmMakefile* m): Makefile(m) { this->Makefile->PushScope(); }
~ScopePushPop() { this->Makefile->PopScope(); }
private:
cmMakefile* Makefile;
};
2008-03-11 17:29:56 +03:00
void IssueMessage(cmake::MessageType t,
std::string const& text) const;
/** Set whether or not to report a CMP0000 violation. */
void SetCheckCMP0000(bool b) { this->CheckCMP0000 = b; }
const std::vector<cmValueWithOrigin>& GetIncludeDirectoriesEntries() const
{
return this->IncludeDirectoriesEntries;
}
const std::vector<cmValueWithOrigin>& GetCompileOptionsEntries() const
{
return this->CompileOptionsEntries;
}
const std::vector<cmValueWithOrigin>& GetCompileDefinitionsEntries() const
{
return this->CompileDefinitionsEntries;
}
bool IsGeneratingBuildSystem() const { return this->GeneratingBuildSystem; }
void SetGeneratingBuildSystem(){ this->GeneratingBuildSystem = true; }
void AddQtUiFileWithOptions(cmSourceFile *sf);
std::vector<cmSourceFile*> GetQtUiFilesWithOptions() const;
std::set<std::string> const & GetSystemIncludeDirectories() const
{ return this->SystemIncludeDirectories; }
bool PolicyOptionalWarningEnabled(std::string const& var);
bool AddRequiredTargetFeature(cmTarget *target,
const std::string& feature,
std::string *error = 0) const;
bool CompileFeatureKnown(cmTarget const* target, const std::string& feature,
std::string& lang, std::string *error) const;
const char* CompileFeaturesAvailable(const std::string& lang,
std::string *error) const;
bool HaveFeatureAvailable(cmTarget const* target, std::string const& lang,
const std::string& feature) const;
bool IsLaterStandard(std::string const& lang,
std::string const& lhs,
std::string const& rhs);
protected:
// add link libraries and directories to the target
2014-02-07 02:31:47 +04:00
void AddGlobalLinkInformation(const std::string& name, cmTarget& target);
2010-09-14 23:22:31 +04:00
// Check for a an unused variable
void CheckForUnused(const char* reason, const std::string& name) const;
2010-09-14 23:22:31 +04:00
2006-03-15 19:02:08 +03:00
std::string Prefix;
2011-10-13 21:51:18 +04:00
std::vector<std::string> AuxSourceDirectories; //
2001-02-15 21:30:13 +03:00
2011-10-13 21:51:18 +04:00
std::string cmStartDirectory;
std::string StartOutputDirectory;
std::string cmHomeDirectory;
2006-03-15 19:02:08 +03:00
std::string HomeOutputDirectory;
std::string cmCurrentListFile;
2001-02-15 21:30:13 +03:00
2006-03-15 19:02:08 +03:00
std::string ProjectName; // project name
// libraries, classes, and executables
2013-11-19 14:47:36 +04:00
mutable cmTargets Targets;
#if defined(CMAKE_BUILD_WITH_CMAKE)
typedef cmsys::hash_map<std::string, cmTarget*> TargetMap;
#else
typedef std::map<std::string, cmTarget*> TargetMap;
#endif
TargetMap AliasTargets;
cmGeneratorTargetsType GeneratorTargets;
2006-03-15 19:02:08 +03:00
std::vector<cmSourceFile*> SourceFiles;
// Tests
std::map<std::string, cmTest*> Tests;
2011-10-13 21:51:18 +04:00
// The link-library paths. Order matters, use std::vector (not std::set).
2006-03-15 19:02:08 +03:00
std::vector<std::string> LinkDirectories;
// The set of include directories that are marked as system include
// directories.
std::set<std::string> SystemIncludeDirectories;
2006-03-15 19:02:08 +03:00
std::vector<std::string> ListFiles; // list of command files loaded
std::vector<std::string> OutputFiles; // list of command files loaded
2011-10-13 21:51:18 +04:00
2006-03-15 19:02:08 +03:00
cmTarget::LinkLibraryVectorType LinkLibraries;
std::vector<cmInstallGenerator*> InstallGenerators;
std::vector<cmTestGenerator*> TestGenerators;
2006-03-15 19:02:08 +03:00
std::string IncludeFileRegularExpression;
std::string ComplainFileRegularExpression;
std::vector<std::string> SourceFileExtensions;
std::vector<std::string> HeaderFileExtensions;
std::string DefineFlags;
2006-03-22 17:58:11 +03:00
std::vector<cmValueWithOrigin> IncludeDirectoriesEntries;
std::vector<cmValueWithOrigin> CompileOptionsEntries;
std::vector<cmValueWithOrigin> CompileDefinitionsEntries;
// Track the value of the computed DEFINITIONS property.
void AddDefineFlag(const char*, std::string&);
void RemoveDefineFlag(const char*, std::string::size_type, std::string&);
std::string DefineFlagsOrig;
2006-03-22 17:58:11 +03:00
#if defined(CMAKE_BUILD_WITH_CMAKE)
2006-03-15 19:02:08 +03:00
std::vector<cmSourceGroup> SourceGroups;
2006-03-22 17:58:11 +03:00
#endif
std::vector<cmCommand*> FinalPassCommands;
2006-03-15 19:02:08 +03:00
cmLocalGenerator* LocalGenerator;
2011-10-13 21:51:18 +04:00
bool IsFunctionBlocked(const cmListFileFunction& lff,
cmExecutionStatus &status);
2011-10-13 21:51:18 +04:00
2001-01-11 22:47:38 +03:00
private:
void Initialize();
2001-01-11 22:47:38 +03:00
bool ParseDefineFlag(std::string const& definition, bool remove);
bool EnforceUniqueDir(const std::string& srcPath,
const std::string& binPath) const;
2006-03-16 18:53:14 +03:00
friend class cmMakeDepend; // make depend needs direct access
2011-10-13 21:51:18 +04:00
// to the Sources array
void PrintStringVector(const char* s, const
std::vector<std::pair<std::string, bool> >& v) const;
2011-10-13 21:51:18 +04:00
void PrintStringVector(const char* s,
2006-03-10 19:13:15 +03:00
const std::vector<std::string>& v) const;
2006-03-15 19:02:08 +03:00
void AddDefaultDefinitions();
typedef std::vector<cmFunctionBlocker*> FunctionBlockersType;
FunctionBlockersType FunctionBlockers;
std::vector<FunctionBlockersType::size_type> FunctionBlockerBarriers;
void PushFunctionBlockerBarrier();
void PopFunctionBlockerBarrier(bool reportError = true);
typedef std::map<std::string, std::string> StringStringMap;
2006-03-15 19:02:08 +03:00
StringStringMap MacrosMap;
std::map<std::string, bool> SubDirectoryOrder;
mutable cmsys::RegularExpression cmDefineRegex;
mutable cmsys::RegularExpression cmDefine01Regex;
mutable cmsys::RegularExpression cmAtVarRegex;
mutable cmsys::RegularExpression cmNamedCurly;
cmPropertyMap Properties;
// should this makefile be processed before or after processing the parent
bool PreOrder;
2006-03-22 22:06:52 +03:00
2010-08-25 00:50:15 +04:00
// Unused variable flags
2010-08-25 20:36:21 +04:00
bool WarnUnused;
2010-09-01 19:24:20 +04:00
bool CheckSystemVars;
2010-08-25 00:50:15 +04:00
2011-10-13 21:51:18 +04:00
// stack of list files being read
std::deque<std::string> ListFileStack;
// stack of commands being invoked.
struct CallStackEntry
{
cmListFileContext const* Context;
cmExecutionStatus* Status;
};
typedef std::deque<CallStackEntry> CallStackType;
CallStackType CallStack;
friend class cmMakefileCall;
std::vector<cmTarget*> ImportedTargetsOwned;
TargetMap ImportedTargets;
// Internal policy stack management.
void PushPolicy(bool weak = false,
cmPolicies::PolicyMap const& pm = cmPolicies::PolicyMap());
void PopPolicy();
void PushPolicyBarrier();
void PopPolicyBarrier(bool reportError = true);
friend class cmCMakePolicyCommand;
class IncludeScope;
friend class IncludeScope;
// stack of policy settings
struct PolicyStackEntry: public cmPolicies::PolicyMap
{
typedef cmPolicies::PolicyMap derived;
PolicyStackEntry(bool w = false): derived(), Weak(w) {}
PolicyStackEntry(derived const& d, bool w = false): derived(d), Weak(w) {}
PolicyStackEntry(PolicyStackEntry const& r): derived(r), Weak(r.Weak) {}
bool Weak;
};
typedef std::vector<PolicyStackEntry> PolicyStackType;
PolicyStackType PolicyStack;
std::vector<PolicyStackType::size_type> PolicyBarriers;
cmPolicies::PolicyStatus
GetPolicyStatusInternal(cmPolicies::PolicyID id) const;
bool CheckCMP0000;
// Enforce rules about CMakeLists.txt files.
void EnforceDirectoryLevelRules() const;
// CMP0053 == old
cmake::MessageType ExpandVariablesInStringOld(
std::string& errorstr,
std::string& source,
bool escapeQuotes,
bool noEscapes,
bool atOnly,
const char* filename,
long line,
bool removeEmpty,
bool replaceAt) const;
// CMP0053 == new
cmake::MessageType ExpandVariablesInStringNew(
std::string& errorstr,
std::string& source,
bool escapeQuotes,
bool noEscapes,
bool atOnly,
const char* filename,
long line,
bool removeEmpty,
bool replaceAt) const;
bool GeneratingBuildSystem;
/**
* Old version of GetSourceFileWithOutput(const std::string&) kept for
* backward-compatibility. It implements a linear search and support
* relative file paths. It is used as a fall back by
* GetSourceFileWithOutput(const std::string&).
*/
cmSourceFile *LinearGetSourceFileWithOutput(const std::string& cname) const;
// A map for fast output to input look up.
#if defined(CMAKE_BUILD_WITH_CMAKE)
typedef cmsys::hash_map<std::string, cmSourceFile*> OutputToSourceMap;
#else
typedef std::map<std::string, cmSourceFile*> OutputToSourceMap;
#endif
OutputToSourceMap OutputToSource;
void UpdateOutputToSourceMap(std::vector<std::string> const& outputs,
cmSourceFile* source);
void UpdateOutputToSourceMap(std::string const& output,
cmSourceFile* source);
std::vector<cmSourceFile*> QtUiFilesWithOptions;
bool AddRequiredTargetCFeature(cmTarget *target,
const std::string& feature) const;
bool AddRequiredTargetCxxFeature(cmTarget *target,
const std::string& feature) const;
void CheckNeededCLanguage(const std::string& feature, bool& needC90,
bool& needC99, bool& needC11) const;
void CheckNeededCxxLanguage(const std::string& feature, bool& needCxx98,
bool& needCxx11, bool& needCxx14) const;
bool HaveCFeatureAvailable(cmTarget const* target,
const std::string& feature) const;
bool HaveCxxFeatureAvailable(cmTarget const* target,
const std::string& feature) const;
mutable bool SuppressWatches;
};
//----------------------------------------------------------------------------
// Helper class to make sure the call stack is valid.
class cmMakefileCall
{
public:
cmMakefileCall(cmMakefile* mf,
cmListFileContext const& lfc,
cmExecutionStatus& status): Makefile(mf)
{
cmMakefile::CallStackEntry entry = {&lfc, &status};
this->Makefile->CallStack.push_back(entry);
}
~cmMakefileCall()
{
this->Makefile->CallStack.pop_back();
}
private:
cmMakefile* Makefile;
};
#endif