CMake/Source/cmMakefile.h

1034 lines
32 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"
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>
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();
unsigned int GetCacheMinorVersion();
/* Check for unused variables in this scope */
void CheckForUnusedVariables() const;
/* Mark a variable as used */
void MarkVariableAsUsed(const char* var);
/* return true if a variable has been initialized */
bool VariableInitialized(const char* ) const;
2010-08-25 00:50:15 +04:00
/* return true if a variable has been used */
bool VariableUsed(const char* ) const;
/** Return whether compatibility features needed for a version of
the cache or lower should be enabled. */
bool NeedCacheCompatibility(int major, int minor);
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.
*/
2011-10-13 21:51:18 +04:00
int TryCompile(const char *srcdir, const char *bindir,
const char *projectName, const char *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.
2011-10-13 21:51:18 +04:00
cmLocalGenerator* GetLocalGenerator()
2006-03-15 19:02:08 +03:00
{ return this->LocalGenerator;}
2001-01-11 22:47:38 +03:00
/**
* Test whether compatibility is set to a given version or lower.
*/
bool NeedBackwardsCompatibility(unsigned int major,
unsigned int minor,
unsigned int patch = 0xFFu);
/**
* Help enforce global target name uniqueness.
*/
bool EnforceUniqueName(std::string const& name, std::string& msg,
bool isCustom = false);
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();
/** Add a custom command to the build. */
void AddCustomCommandToTarget(const char* target,
const std::vector<std::string>& depends,
const cmCustomCommandLines& commandLines,
cmTarget::CustomCommandType type,
const char* comment, const char* workingDir,
bool escapeOldStyle = true);
cmSourceFile* AddCustomCommandToOutput(
const std::vector<std::string>& outputs,
const std::vector<std::string>& depends,
const char* main_dependency,
const cmCustomCommandLines& commandLines,
const char* comment, const char* workingDir,
bool replace = false,
bool escapeOldStyle = true);
cmSourceFile* AddCustomCommandToOutput(
const char* output,
const std::vector<std::string>& depends,
const char* main_dependency,
const cmCustomCommandLines& commandLines,
const char* comment, const char* workingDir,
bool replace = false,
bool escapeOldStyle = true);
void AddCustomCommandOldStyle(const char* target,
const std::vector<std::string>& outputs,
const std::vector<std::string>& depends,
const char* 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);
2001-01-11 22:47:38 +03:00
/** Create a new imported target with the name and type given. */
cmTarget* AddImportedTarget(const char* name, cmTarget::TargetType type,
bool global);
cmTarget* AddNewTarget(cmTarget::TargetType type, const char* 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.
*/
2007-03-13 22:18:27 +03:00
void AddUtilityCommand(const char* 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 char* 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.
*/
void AddLinkLibrary(const char*);
void AddLinkLibrary(const char*, cmTarget::LinkLibraryType type);
2011-10-13 21:51:18 +04:00
void AddLinkLibraryForTarget(const char *tgt, const char*,
cmTarget::LinkLibraryType type);
void AddLinkDirectoryForTarget(const char *tgt, const char* d);
2001-01-11 22:47:38 +03:00
/**
* Add a link directory to the build.
*/
void AddLinkDirectory(const char*);
2001-01-11 22:47:38 +03:00
/**
* Get the list of link directories
*/
std::vector<std::string>& GetLinkDirectories()
{
2006-03-15 19:02:08 +03:00
return this->LinkDirectories;
}
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.
*/
2011-10-13 21:51:18 +04:00
void AddSubDirectory(const char*, bool excludeFromAll=false,
2006-03-10 19:13:15 +03:00
bool preorder = false);
2011-10-13 21:51:18 +04:00
void AddSubDirectory(const char* fullSrcDir,const char *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 AddIncludeDirectory(const char*, 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 char* name, const char* value);
///! Add a definition to this makefile and the global cmake cache.
2011-10-13 21:51:18 +04:00
void AddCacheDefinition(const char* 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 char* name, bool);
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 char* name);
///! Remove a definition from the cache.
void RemoveCacheDefinition(const char* 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. */
const char* GetConfigurations(std::vector<std::string>& configs,
bool single = true) const;
2001-01-11 22:47:38 +03:00
/**
* Set the name of the library.
*/
cmTarget* AddLibrary(const char *libname, cmTarget::TargetType type,
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
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 char* 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);
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();
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 char* 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 char* 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
*/
2011-10-13 21:51:18 +04:00
void SetStartDirectory(const char* 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();
}
2001-02-15 21:30:13 +03:00
void SetStartOutputDirectory(const char* lib)
{
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;
}
const char* GetIncludeRegularExpression()
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 char* regex)
{
2006-03-15 19:02:08 +03:00
this->ComplainFileRegularExpression = regex;
}
const char* GetComplainRegularExpression()
{
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 char* name);
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 char* name);
cmGeneratorTarget* FindGeneratorTargetToUse(const char* name);
2006-04-11 20:51:20 +04:00
/**
* Mark include directories as system directories.
*/
void AddSystemIncludeDirectory(const char* dir);
bool IsSystemIncludeDirectory(const char* dir);
/** 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,
2002-07-02 16:24:36 +04:00
unsigned int startArgumentIndex);
/** Get a cmSourceFile pointer for a given source name, if the name is
* not found, then a null pointer is returned.
*/
cmSourceFile* GetSource(const char* sourceName);
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 char* 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.
*/
std::vector<std::string>& GetAuxSourceDirectories()
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.
*/
2002-08-24 00:13:34 +04:00
const char* GetDefinition(const char*) const;
const char* GetSafeDefinition(const char*) const;
2004-08-06 22:51:41 +04:00
const char* GetRequiredDefinition(const char* name) const;
bool IsDefinitionSet(const char*) 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 cache entry to see if it is true or false,
* returns false if no entry defined.
*/
2002-05-01 22:00:21 +04:00
bool IsOn(const char* name) const;
bool IsSet(const char* 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 char* language) const;
/**
2001-01-11 22:47:38 +03:00
* Get a list of preprocessor define flags.
*/
2001-01-11 22:47:38 +03:00
const char* GetDefineFlags()
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);
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);
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 char* file)
2006-03-15 19:02:08 +03:00
{ this->ListFiles.push_back(file);}
/**
* Get the list file stack as a string
*/
std::string GetListFileStack();
/**
* Get the current context backtrace.
*/
bool GetBacktrace(cmListFileBacktrace& backtrace) const;
/**
* Get the vector of files created by this makefile
*/
const std::vector<std::string>& GetOutputFiles() const
{ return this->OutputFiles; }
void AddCMakeOutputFile(const char* 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 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 = true);
/**
* 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
*/
2011-10-13 21:51:18 +04:00
void ExpandVariables();
/**
* 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);
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);
2006-03-22 17:58:11 +03:00
#endif
/**
* Print a command's invocation
*/
void PrintCommandTrace(const cmListFileFunction& lff);
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);
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);
/**
* 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 char *outName);
/**
* 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.
cmTest* CreateTest(const char* testName);
/** Get a cmTest pointer for a given test name, if the name is
* not found, then a null pointer is returned.
*/
cmTest* GetTest(const char* testName) const;
/**
* Get a list of macros as a ; separated string
*/
void GetListOfMacros(std::string& macros);
/**
* Return a location of a file in cmake or custom modules directory
*/
std::string GetModulesFile(const char* name);
2011-10-13 21:51:18 +04:00
///! Set/Get a property of this directory
void SetProperty(const char *prop, const char *value);
void AppendProperty(const char *prop, const char *value,bool asString=false);
2006-03-22 22:06:52 +03:00
const char *GetProperty(const char *prop);
const char *GetPropertyOrDefinition(const char *prop);
const char *GetProperty(const char *prop, cmProperty::ScopeType scope);
bool GetPropertyAsBool(const char *prop);
const char* GetFeature(const char* feature, const char* 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); }
std::vector<cmTestGenerator*>& GetTestGenerators()
{ 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 char *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; }
protected:
// add link libraries and directories to the target
void AddGlobalLinkInformation(const char* name, cmTarget& target);
2010-09-14 23:22:31 +04:00
// Check for a an unused variable
2010-09-16 19:50:57 +04:00
void CheckForUnused(const char* reason, const char* 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
2006-03-15 19:02:08 +03:00
cmTargets Targets;
cmGeneratorTargetsType GeneratorTargets;
2006-03-15 19:02:08 +03:00
std::vector<cmSourceFile*> SourceFiles;
// Tests
std::map<cmStdString, 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<cmStdString> 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
// 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 char* srcPath, const char* binPath);
2001-04-25 00:49:12 +04:00
void ReadSources(std::ifstream& fin, bool t);
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
2006-03-10 19:13:15 +03:00
std::vector<std::pair<cmStdString, 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<cmStdString, cmStdString> StringStringMap;
2006-03-15 19:02:08 +03:00
StringStringMap MacrosMap;
2006-03-15 19:02:08 +03:00
std::map<cmStdString, bool> SubDirectoryOrder;
2006-03-15 19:02:08 +03:00
cmsys::RegularExpression cmDefineRegex;
cmsys::RegularExpression cmDefine01Regex;
cmsys::RegularExpression cmAtVarRegex;
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
2006-03-22 22:06:52 +03:00
std::deque<cmStdString> ListFileStack;
// stack of commands being invoked.
struct CallStackEntry
{
cmListFileContext const* Context;
cmExecutionStatus* Status;
};
typedef std::deque<CallStackEntry> CallStackType;
CallStackType CallStack;
friend class cmMakefileCall;
cmTarget* FindBasicTarget(const char* name);
std::vector<cmTarget*> ImportedTargetsOwned;
std::map<cmStdString, cmTarget*> 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);
bool CheckCMP0000;
// Enforce rules about CMakeLists.txt files.
void EnforceDirectoryLevelRules();
};
//----------------------------------------------------------------------------
// 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