2009-09-28 19:43:28 +04:00
|
|
|
/*============================================================================
|
|
|
|
CMake - Cross Platform Makefile Generator
|
|
|
|
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
|
2000-08-29 23:26:29 +04:00
|
|
|
|
2009-09-28 19:43:28 +04:00
|
|
|
Distributed under the OSI-approved BSD License (the "License");
|
|
|
|
see accompanying file Copyright.txt for details.
|
2000-08-29 23:26:29 +04:00
|
|
|
|
2009-09-28 19:43:28 +04: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.
|
|
|
|
============================================================================*/
|
2000-08-29 23:26:29 +04:00
|
|
|
#ifndef cmMakefile_h
|
|
|
|
#define cmMakefile_h
|
2001-01-11 22:47:38 +03:00
|
|
|
|
2008-01-23 18:28:26 +03:00
|
|
|
#include "cmCacheManager.h"
|
|
|
|
#include "cmExecutionStatus.h"
|
2002-12-12 02:13:33 +03:00
|
|
|
#include "cmListFileCache.h"
|
2008-03-01 23:20:35 +03:00
|
|
|
#include "cmPolicies.h"
|
2006-12-07 17:45:32 +03:00
|
|
|
#include "cmPropertyMap.h"
|
2008-01-23 18:28:26 +03:00
|
|
|
#include "cmSystemTools.h"
|
|
|
|
#include "cmTarget.h"
|
2008-03-11 17:29:56 +03:00
|
|
|
#include "cmake.h"
|
2001-08-08 19:54:46 +04:00
|
|
|
|
2006-03-22 17:58:11 +03:00
|
|
|
#if defined(CMAKE_BUILD_WITH_CMAKE)
|
|
|
|
#include "cmSourceGroup.h"
|
|
|
|
#endif
|
|
|
|
|
2009-01-20 22:36:18 +03:00
|
|
|
#include <cmsys/auto_ptr.hxx>
|
2004-03-04 02:18:47 +03:00
|
|
|
#include <cmsys/RegularExpression.hxx>
|
|
|
|
|
2001-04-20 01:39:03 +04:00
|
|
|
class cmFunctionBlocker;
|
2001-01-18 19:20:24 +03:00
|
|
|
class cmCommand;
|
2006-02-19 23:25:27 +03:00
|
|
|
class cmInstallGenerator;
|
2002-09-06 21:06:23 +04:00
|
|
|
class cmLocalGenerator;
|
2002-01-17 18:48:37 +03:00
|
|
|
class cmMakeDepend;
|
2002-12-02 23:59:59 +03:00
|
|
|
class cmSourceFile;
|
2005-04-24 23:59:51 +04:00
|
|
|
class cmTest;
|
2009-03-16 17:40:46 +03:00
|
|
|
class cmTestGenerator;
|
2003-01-08 20:59:52 +03:00
|
|
|
class cmVariableWatch;
|
2003-01-14 17:53:13 +03:00
|
|
|
class cmake;
|
2008-03-07 16:40:36 +03:00
|
|
|
class cmMakefileCall;
|
2009-01-22 18:57:09 +03:00
|
|
|
class cmCMakePolicyCommand;
|
2001-01-05 19:41:20 +03:00
|
|
|
|
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.
|
|
|
|
*/
|
2000-08-29 23:26:29 +04:00
|
|
|
class cmMakefile
|
|
|
|
{
|
2009-07-22 22:22:45 +04:00
|
|
|
class Internals;
|
|
|
|
cmsys::auto_ptr<Internals> Internal;
|
2000-08-29 23:26:29 +04:00
|
|
|
public:
|
2001-06-07 22:52:29 +04:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2002-08-28 22:51:10 +04:00
|
|
|
unsigned int GetCacheMajorVersion();
|
|
|
|
unsigned int GetCacheMinorVersion();
|
2008-01-24 15:37:08 +03:00
|
|
|
|
2010-08-24 22:38:06 +04:00
|
|
|
/* 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;
|
2010-04-13 17:21:31 +04:00
|
|
|
/* return true if a variable has been set with
|
|
|
|
set(foo )
|
|
|
|
*/
|
|
|
|
bool VariableCleared(const char* ) const;
|
2008-01-24 15:37:08 +03:00
|
|
|
/** Return whether compatibility features needed for a version of
|
|
|
|
the cache or lower should be enabled. */
|
|
|
|
bool NeedCacheCompatibility(int major, int minor);
|
2001-05-24 19:47:21 +04:00
|
|
|
|
2001-01-11 22:47:38 +03:00
|
|
|
/**
|
|
|
|
* Construct an empty makefile.
|
|
|
|
*/
|
2002-08-24 00:13:34 +04:00
|
|
|
cmMakefile();
|
2006-07-09 21:19:36 +04:00
|
|
|
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.
|
|
|
|
*/
|
ENH: merge CMake-CrossCompileBasic to HEAD
-add a RESULT_VARIABLE to INCLUDE()
-add CMAKE_TOOLCHAIN_FILE for specifiying your (potentially crosscompiling) toolchain
-have TRY_RUN() complain if you try to use it in crosscompiling mode (which were compiled but cannot run on this system)
-use CMAKE_EXECUTABLE_SUFFIX in TRY_RUN(), probably TRY_RUN won't be able to
run the executables if they have a different suffix because they are
probably crosscompiled, but nevertheless it should be able to find them
-make several cmake variables presettable by the user: CMAKE_C/CXX_COMPILER, CMAKE_C/CXX_OUTPUT_EXTENSION, CMAKE_SYSTEM_NAME, CMAKE_SYSTEM_INFO_FILE
-support prefix for GNU toolchains (arm-elf-gcc, arm-elf-ar, arm-elf-strip etc.)
-move ranlib on OSX from the file command to a command in executed in cmake_install.cmake
-add support for stripping during install in cmake_install.cmake
-split out cl.cmake from Windows-cl.cmake, first (very incomplete) step to support MS crosscompiling tools
-remove stdio.h from the simple C program which checks if the compiler works, since this may not exist for some embedded platforms
-create a new CMakeFindBinUtils.cmake which collects the search fro ar, ranlib, strip, ld, link, install_name_tool and other tools like these
-add support for CMAKE_FIND_ROOT_PATH for all FIND_XXX commands, which is a
list of directories which will be prepended to all search directories, right
now as a cmake variable, turning it into a global cmake property may need
some more work
-remove cmTestTestHandler::TryExecutable(), it's unused
-split cmFileCommand::HandleInstall() into slightly smaller functions
Alex
2007-05-17 21:20:44 +04:00
|
|
|
bool ReadListFile(const char* listfile,
|
|
|
|
const char* external= 0,
|
2009-01-22 21:18:40 +03:00
|
|
|
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
|
|
|
|
*/
|
2009-01-21 17:48:20 +03:00
|
|
|
void AddFunctionBlocker(cmFunctionBlocker* fb);
|
2009-01-20 22:36:18 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Remove the function blocker whose scope ends with the given command.
|
|
|
|
* This returns ownership of the function blocker object.
|
|
|
|
*/
|
|
|
|
cmsys::auto_ptr<cmFunctionBlocker>
|
2009-01-21 17:49:00 +03:00
|
|
|
RemoveFunctionBlocker(cmFunctionBlocker* fb, const cmListFileFunction& lff);
|
2004-04-18 22:41:46 +04:00
|
|
|
|
2009-01-21 17:48:00 +03:00
|
|
|
/** 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;
|
|
|
|
|
2002-08-28 22:51:10 +04:00
|
|
|
/**
|
|
|
|
* Try running cmake and building a file. This is used for dynalically
|
|
|
|
* loaded commands, not as part of the usual build process.
|
|
|
|
*/
|
|
|
|
int TryCompile(const char *srcdir, const char *bindir,
|
2002-09-18 19:37:40 +04:00
|
|
|
const char *projectName, const char *targetName,
|
2009-08-04 22:37:46 +04:00
|
|
|
bool fast,
|
2002-09-20 21:15:56 +04:00
|
|
|
const std::vector<std::string> *cmakeArgs,
|
|
|
|
std::string *output);
|
2002-08-28 22:51:10 +04:00
|
|
|
|
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*);
|
2001-05-02 00:55:32 +04:00
|
|
|
|
|
|
|
///! Get the current makefile generator.
|
2002-09-06 21:06:23 +04:00
|
|
|
cmLocalGenerator* GetLocalGenerator()
|
2006-03-15 19:02:08 +03:00
|
|
|
{ return this->LocalGenerator;}
|
2001-01-11 22:47:38 +03:00
|
|
|
|
2008-02-11 21:35:30 +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);
|
|
|
|
|
2008-02-11 21:35:39 +03:00
|
|
|
/**
|
|
|
|
* Help enforce global target name uniqueness.
|
|
|
|
*/
|
2008-02-15 00:42:29 +03:00
|
|
|
bool EnforceUniqueName(std::string const& name, std::string& msg,
|
|
|
|
bool isCustom = false);
|
2008-02-11 21:35:39 +03:00
|
|
|
|
2001-01-11 22:47:38 +03:00
|
|
|
/**
|
2002-09-15 16:52:24 +04:00
|
|
|
* Perform FinalPass, Library dependency analysis etc before output of the
|
|
|
|
* makefile.
|
2001-01-11 22:47:38 +03:00
|
|
|
*/
|
2002-09-15 16:52:24 +04:00
|
|
|
void ConfigureFinalPass();
|
2001-07-26 02:30:27 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* run the final pass on all commands.
|
|
|
|
*/
|
|
|
|
void FinalPass();
|
|
|
|
|
2001-01-11 22:47:38 +03:00
|
|
|
/**
|
|
|
|
* Print the object state to std::cout.
|
|
|
|
*/
|
2005-06-22 17:06:46 +04:00
|
|
|
void Print();
|
2005-02-22 18:32:44 +03:00
|
|
|
|
|
|
|
/** Add a custom command to the build. */
|
|
|
|
void AddCustomCommandToTarget(const char* target,
|
|
|
|
const std::vector<std::string>& depends,
|
|
|
|
const cmCustomCommandLines& commandLines,
|
|
|
|
cmTarget::CustomCommandType type,
|
2006-09-28 19:30:49 +04:00
|
|
|
const char* comment, const char* workingDir,
|
|
|
|
bool escapeOldStyle = true);
|
2006-04-11 19:06:19 +04:00
|
|
|
void 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,
|
2006-09-28 19:30:49 +04:00
|
|
|
bool replace = false,
|
|
|
|
bool escapeOldStyle = true);
|
2003-06-03 18:30:23 +04:00
|
|
|
void AddCustomCommandToOutput(const char* output,
|
|
|
|
const std::vector<std::string>& depends,
|
2005-02-22 18:32:44 +03:00
|
|
|
const char* main_dependency,
|
|
|
|
const cmCustomCommandLines& commandLines,
|
2006-02-08 18:58:36 +03:00
|
|
|
const char* comment, const char* workingDir,
|
2006-09-28 19:30:49 +04:00
|
|
|
bool replace = false,
|
|
|
|
bool escapeOldStyle = true);
|
2005-02-22 18:32:44 +03:00
|
|
|
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.
|
|
|
|
*/
|
2001-01-05 19:41:20 +03:00
|
|
|
void AddDefineFlag(const char* definition);
|
2004-04-15 21:58:10 +04:00
|
|
|
void RemoveDefineFlag(const char* definition);
|
2001-01-11 22:47:38 +03:00
|
|
|
|
2008-01-28 16:38:36 +03:00
|
|
|
/** Create a new imported target with the name and type given. */
|
|
|
|
cmTarget* AddImportedTarget(const char* name, cmTarget::TargetType type);
|
|
|
|
|
|
|
|
cmTarget* AddNewTarget(cmTarget::TargetType type, const char* name);
|
2007-05-22 18:24:59 +04:00
|
|
|
|
2001-01-11 22:47:38 +03:00
|
|
|
/**
|
|
|
|
* Add an executable to the build.
|
|
|
|
*/
|
2004-02-29 02:59:19 +03:00
|
|
|
cmTarget* AddExecutable(const char *exename,
|
2006-10-02 19:14:00 +04:00
|
|
|
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
|
|
|
|
2001-05-02 00:55:32 +04:00
|
|
|
/**
|
2005-02-22 18:32:44 +03:00
|
|
|
* Add a utility to the build. A utiltity target is a command that
|
|
|
|
* is run every time the target is built.
|
2001-05-02 00:55:32 +04:00
|
|
|
*/
|
2007-03-13 22:18:27 +03:00
|
|
|
void AddUtilityCommand(const char* utilityName, bool excludeFromAll,
|
2005-02-22 18:32:44 +03:00
|
|
|
const std::vector<std::string>& depends,
|
2006-02-08 18:58:36 +03:00
|
|
|
const char* workingDirectory,
|
2001-05-04 23:50:26 +04:00
|
|
|
const char* command,
|
2005-02-22 18:32:44 +03:00
|
|
|
const char* arg1=0,
|
|
|
|
const char* arg2=0,
|
2005-06-17 00:33:24 +04:00
|
|
|
const char* arg3=0,
|
|
|
|
const char* arg4=0);
|
2008-10-09 19:00:54 +04:00
|
|
|
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-05-02 00:55:32 +04:00
|
|
|
|
2001-01-11 22:47:38 +03:00
|
|
|
/**
|
|
|
|
* Add a link library to the build.
|
|
|
|
*/
|
2001-01-05 19:41:20 +03:00
|
|
|
void AddLinkLibrary(const char*);
|
2001-04-30 18:44:00 +04:00
|
|
|
void AddLinkLibrary(const char*, cmTarget::LinkLibraryType type);
|
|
|
|
void AddLinkLibraryForTarget(const char *tgt, const char*,
|
|
|
|
cmTarget::LinkLibraryType type);
|
2002-05-02 21:17:10 +04:00
|
|
|
void AddLinkDirectoryForTarget(const char *tgt, const char* d);
|
2001-01-11 22:47:38 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Add a link directory to the build.
|
|
|
|
*/
|
2001-01-05 19:41:20 +03:00
|
|
|
void AddLinkDirectory(const char*);
|
2001-01-11 22:47:38 +03:00
|
|
|
|
2004-04-24 00:20:36 +04:00
|
|
|
/**
|
|
|
|
* Get the list of link directories
|
|
|
|
*/
|
|
|
|
std::vector<std::string>& GetLinkDirectories()
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
return this->LinkDirectories;
|
2004-04-24 00:20:36 +04:00
|
|
|
}
|
|
|
|
const std::vector<std::string>& GetLinkDirectories() const
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
return this->LinkDirectories;
|
2004-04-24 00:20:36 +04:00
|
|
|
}
|
|
|
|
void SetLinkDirectories(const std::vector<std::string>& vec)
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
this->LinkDirectories = vec;
|
2004-04-24 00:20:36 +04:00
|
|
|
}
|
|
|
|
|
2001-01-11 22:47:38 +03:00
|
|
|
/**
|
|
|
|
* Add a subdirectory to the build.
|
|
|
|
*/
|
2007-03-12 17:26:59 +03:00
|
|
|
void AddSubDirectory(const char*, bool excludeFromAll=false,
|
2006-03-10 19:13:15 +03:00
|
|
|
bool preorder = false);
|
2005-03-14 19:29:15 +03:00
|
|
|
void AddSubDirectory(const char* fullSrcDir,const char *fullBinDir,
|
2007-03-12 17:26:59 +03:00
|
|
|
bool excludeFromAll, bool preorder,
|
2005-03-18 18:41:41 +03:00
|
|
|
bool immediate);
|
2001-01-11 22:47:38 +03:00
|
|
|
|
2005-03-18 18:41:41 +03:00
|
|
|
/**
|
|
|
|
* Configure a subdirectory
|
|
|
|
*/
|
|
|
|
void ConfigureSubDirectory(cmLocalGenerator *);
|
|
|
|
|
2001-01-11 22:47:38 +03:00
|
|
|
/**
|
|
|
|
* Add an include directory to the build.
|
|
|
|
*/
|
2001-11-03 06:32:39 +03:00
|
|
|
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.
|
|
|
|
*/
|
2001-01-05 19:41:20 +03:00
|
|
|
void AddDefinition(const char* name, const char* value);
|
2001-08-08 19:54:46 +04:00
|
|
|
///! Add a definition to this makefile and the global cmake cache.
|
|
|
|
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
|
|
|
/**
|
|
|
|
* Add bool variable definition to the build.
|
|
|
|
*/
|
|
|
|
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);
|
2008-08-25 18:31:29 +04:00
|
|
|
///! Remove a definition from the cache.
|
|
|
|
void RemoveCacheDefinition(const char* name);
|
2002-09-18 18:39:41 +04:00
|
|
|
|
2001-01-11 22:47:38 +03:00
|
|
|
/**
|
|
|
|
* Specify the name of the project for this build.
|
|
|
|
*/
|
2001-01-05 19:41:20 +03:00
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the name of the library.
|
|
|
|
*/
|
2007-06-22 17:58:10 +04:00
|
|
|
void AddLibrary(const char *libname, cmTarget::TargetType type,
|
2006-10-02 19:14:00 +04:00
|
|
|
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)
|
2001-03-20 21:20:59 +03:00
|
|
|
/**
|
2007-08-24 22:21:49 +04:00
|
|
|
* Add a root source group for consideration when adding a new source.
|
2001-03-20 21:20:59 +03:00
|
|
|
*/
|
2007-08-26 11:17:11 +04:00
|
|
|
void AddSourceGroup(const char* name, const char* regex=0);
|
2007-08-24 22:21:49 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Add a source group for consideration when adding a new source.
|
|
|
|
* name is tokenized.
|
|
|
|
*/
|
|
|
|
void AddSourceGroup(const std::vector<std::string>& name,
|
2007-08-26 11:17:11 +04:00
|
|
|
const char* regex=0);
|
2007-08-24 22:21:49 +04:00
|
|
|
|
2006-03-22 17:58:11 +03:00
|
|
|
#endif
|
2008-03-01 23:20:35 +03: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);
|
2009-01-22 21:16:47 +03:00
|
|
|
void RecordPolicies(cmPolicies::PolicyMap& pm);
|
2008-03-01 23:20:35 +03:00
|
|
|
//@}
|
|
|
|
|
2009-01-22 18:56:50 +03:00
|
|
|
/** Helper class to push and pop policies automatically. */
|
|
|
|
class PolicyPushPop
|
|
|
|
{
|
|
|
|
public:
|
2009-01-22 21:16:27 +03:00
|
|
|
PolicyPushPop(cmMakefile* m,
|
|
|
|
bool weak = false,
|
|
|
|
cmPolicies::PolicyMap const& pm = cmPolicies::PolicyMap());
|
2009-01-22 18:56:50 +03:00
|
|
|
~PolicyPushPop();
|
2009-01-22 18:57:16 +03:00
|
|
|
void Quiet() { this->ReportError = false; }
|
2009-01-22 18:56:50 +03:00
|
|
|
private:
|
|
|
|
cmMakefile* Makefile;
|
2009-01-22 18:57:16 +03:00
|
|
|
bool ReportError;
|
2009-01-22 18:56:50 +03:00
|
|
|
};
|
|
|
|
friend class PolicyPushPop;
|
|
|
|
|
2008-03-01 23:20:35 +03:00
|
|
|
/**
|
|
|
|
* Get the Policies Instance
|
|
|
|
*/
|
|
|
|
cmPolicies *GetPolicies();
|
|
|
|
|
2001-01-11 22:47:38 +03:00
|
|
|
/**
|
|
|
|
* Add an auxiliary directory to the build.
|
|
|
|
*/
|
2001-01-05 19:41:20 +03:00
|
|
|
void AddExtraDirectory(const char* dir);
|
|
|
|
|
2001-02-15 21:30:13 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Add an auxiliary directory to the build.
|
|
|
|
*/
|
|
|
|
void MakeStartDirectoriesCurrent()
|
|
|
|
{
|
2005-07-07 19:44:36 +04:00
|
|
|
this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR",
|
2006-03-15 19:02:08 +03:00
|
|
|
this->cmStartDirectory.c_str());
|
2005-07-07 19:44:36 +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-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
|
|
|
|
* and going up until it reaches the HomeDirectory.
|
2001-01-11 22:47:38 +03:00
|
|
|
*/
|
2001-04-30 18:44:00 +04:00
|
|
|
void SetHomeDirectory(const char* dir);
|
2001-04-25 00:49:12 +04:00
|
|
|
const char* GetHomeDirectory() const
|
2000-08-29 23:26:29 +04:00
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
return this->cmHomeDirectory.c_str();
|
2000-08-29 23:26:29 +04:00
|
|
|
}
|
2001-04-30 18:44:00 +04:00
|
|
|
void SetHomeOutputDirectory(const char* lib);
|
2001-04-25 00:49:12 +04:00
|
|
|
const char* GetHomeOutputDirectory() const
|
2000-08-29 23:26:29 +04:00
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
return this->HomeOutputDirectory.c_str();
|
2000-08-29 23:26:29 +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 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
|
|
|
|
* it reaches the HomeDirectory.
|
2001-01-11 22:47:38 +03:00
|
|
|
*/
|
2001-02-15 21:30:13 +03:00
|
|
|
void SetStartDirectory(const char* dir)
|
2000-08-29 23:26:29 +04:00
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
this->cmStartDirectory = dir;
|
|
|
|
cmSystemTools::ConvertToUnixSlashes(this->cmStartDirectory);
|
2006-04-20 23:49:56 +04:00
|
|
|
this->cmStartDirectory =
|
|
|
|
cmSystemTools::CollapseFullPath(this->cmStartDirectory.c_str());
|
2005-07-07 19:44:36 +04:00
|
|
|
this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR",
|
2006-03-15 19:02:08 +03:00
|
|
|
this->cmStartDirectory.c_str());
|
2000-08-29 23:26:29 +04:00
|
|
|
}
|
2001-04-25 00:49:12 +04:00
|
|
|
const char* GetStartDirectory() const
|
2000-08-29 23:26:29 +04:00
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
return this->cmStartDirectory.c_str();
|
2000-08-29 23:26:29 +04:00
|
|
|
}
|
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);
|
2006-04-20 23:49:56 +04:00
|
|
|
this->StartOutputDirectory =
|
|
|
|
cmSystemTools::CollapseFullPath(this->StartOutputDirectory.c_str());
|
2006-03-15 19:02:08 +03:00
|
|
|
cmSystemTools::MakeDirectory(this->StartOutputDirectory.c_str());
|
2005-07-07 19:44:36 +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
|
2000-08-29 23:26:29 +04:00
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
return this->StartOutputDirectory.c_str();
|
2000-08-29 23:26:29 +04:00
|
|
|
}
|
2001-02-15 21:30:13 +03:00
|
|
|
//@}
|
2001-01-11 22:47:38 +03:00
|
|
|
|
2001-04-25 00:49:12 +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
|
|
|
//@}
|
2001-03-16 02:09:16 +03: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;
|
2001-03-16 02:09:16 +03:00
|
|
|
}
|
2004-04-24 00:20:36 +04:00
|
|
|
const char* GetIncludeRegularExpression()
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
return this->IncludeFileRegularExpression.c_str();
|
2004-04-24 00:20:36 +04:00
|
|
|
}
|
2001-03-16 02:09:16 +03:00
|
|
|
|
2001-06-21 23:02:52 +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;
|
2001-06-21 23:02:52 +04:00
|
|
|
}
|
2005-02-07 23:09:22 +03:00
|
|
|
const char* GetComplainRegularExpression()
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
return this->ComplainFileRegularExpression.c_str();
|
2005-02-07 23:09:22 +03:00
|
|
|
}
|
2001-06-21 23:02:52 +04:00
|
|
|
|
2001-01-11 22:47:38 +03:00
|
|
|
/**
|
2001-04-11 22:59:02 +04: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; }
|
2007-06-15 18:10:24 +04:00
|
|
|
/**
|
|
|
|
* Get the list of targets, const version
|
|
|
|
*/
|
|
|
|
const cmTargets &GetTargets() const { return this->Targets; }
|
2001-01-11 22:47:38 +03:00
|
|
|
|
2008-01-28 16:38:36 +03:00
|
|
|
cmTarget* FindTarget(const char* name);
|
2001-01-11 22:47:38 +03:00
|
|
|
|
2008-01-28 16:38:36 +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);
|
2006-04-11 20:51:20 +04:00
|
|
|
|
2001-01-11 22:47:38 +03:00
|
|
|
/**
|
|
|
|
* Get a list of include directories in the build.
|
|
|
|
*/
|
2001-07-30 19:34:03 +04:00
|
|
|
std::vector<std::string>& GetIncludeDirectories()
|
2001-01-05 19:41:20 +03:00
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
return this->IncludeDirectories;
|
2001-01-05 19:41:20 +03:00
|
|
|
}
|
2001-07-30 19:34:03 +04:00
|
|
|
const std::vector<std::string>& GetIncludeDirectories() const
|
2001-06-12 00:47:15 +04:00
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
return this->IncludeDirectories;
|
2001-06-12 00:47:15 +04:00
|
|
|
}
|
2004-04-24 00:20:36 +04:00
|
|
|
void SetIncludeDirectories(const std::vector<std::string>& vec)
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
this->IncludeDirectories = vec;
|
2004-04-24 00:20:36 +04:00
|
|
|
}
|
2001-01-11 22:47:38 +03:00
|
|
|
|
2006-10-05 16:55:59 +04:00
|
|
|
/**
|
|
|
|
* Mark include directories as system directories.
|
|
|
|
*/
|
|
|
|
void AddSystemIncludeDirectory(const char* dir);
|
|
|
|
bool IsSystemIncludeDirectory(const char* dir);
|
|
|
|
|
2002-06-27 23:57:09 +04:00
|
|
|
/** Expand out any arguements in the vector that have ; separated
|
|
|
|
* 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
|
|
|
*/
|
2002-06-27 23:57:09 +04: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);
|
2002-06-27 23:57:09 +04:00
|
|
|
|
2002-03-29 18:06:30 +03:00
|
|
|
/** Get a cmSourceFile pointer for a given source name, if the name is
|
|
|
|
* not found, then a null pointer is returned.
|
|
|
|
*/
|
2007-06-18 19:59:23 +04:00
|
|
|
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
|
|
|
|
* not found, then 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
|
|
|
|
*/
|
2007-06-18 19:59:23 +04:00
|
|
|
cmSourceFile* GetOrCreateSource(const char* sourceName,
|
2003-06-03 18:30:23 +04:00
|
|
|
bool generated = false);
|
2007-06-18 19:59:23 +04:00
|
|
|
|
2001-01-11 22:47:38 +03:00
|
|
|
/**
|
|
|
|
* Obtain a list of auxiliary source directories.
|
|
|
|
*/
|
2001-01-05 19:41:20 +03:00
|
|
|
std::vector<std::string>& GetAuxSourceDirectories()
|
2006-03-15 19:02:08 +03:00
|
|
|
{return this->AuxSourceDirectories;}
|
2001-01-05 19:41:20 +03:00
|
|
|
|
2001-07-17 02:40:42 +04:00
|
|
|
//@{
|
|
|
|
/**
|
|
|
|
* 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;}
|
2001-07-17 02:40:42 +04:00
|
|
|
const std::vector<std::string>& GetHeaderExtensions() const
|
2006-03-15 19:02:08 +03:00
|
|
|
{return this->HeaderFileExtensions;}
|
2001-07-17 02:40:42 +04:00
|
|
|
//@}
|
|
|
|
|
2001-01-11 22:47:38 +03:00
|
|
|
/**
|
|
|
|
* Given a variable name, return its value (as a string).
|
2001-08-08 19:54:46 +04:00
|
|
|
* If the variable is not found in this makefile instance, the
|
|
|
|
* cache is then queried.
|
2001-01-05 19:41:20 +03:00
|
|
|
*/
|
2002-08-24 00:13:34 +04:00
|
|
|
const char* GetDefinition(const char*) const;
|
2004-04-27 19:30:31 +04:00
|
|
|
const char* GetSafeDefinition(const char*) const;
|
2004-08-06 22:51:41 +04:00
|
|
|
const char* GetRequiredDefinition(const char* name) const;
|
2007-05-18 01:40:59 +04:00
|
|
|
bool IsDefinitionSet(const char*) const;
|
2003-03-06 19:19:28 +03:00
|
|
|
/**
|
|
|
|
* 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;
|
2001-08-08 19:54:46 +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;
|
2005-04-02 00:48:46 +04:00
|
|
|
bool IsSet(const char* name) const;
|
2001-01-11 22:47:38 +03:00
|
|
|
|
2009-09-30 21:45:14 +04:00
|
|
|
/** Return whether the target platform is 64-bit. */
|
|
|
|
bool PlatformIs64Bit() const;
|
|
|
|
|
2001-01-05 19:41:20 +03:00
|
|
|
/**
|
2001-01-11 22:47:38 +03:00
|
|
|
* Get a list of preprocessor define flags.
|
2001-01-05 19:41:20 +03:00
|
|
|
*/
|
2001-01-11 22:47:38 +03:00
|
|
|
const char* GetDefineFlags()
|
2006-03-15 19:02:08 +03:00
|
|
|
{return this->DefineFlags.c_str();}
|
2006-03-22 22:40:36 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Make sure CMake can write this file
|
|
|
|
*/
|
|
|
|
bool CanIWriteThisFile(const char* fileName);
|
2001-02-27 01:58:54 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the vector of used command instances.
|
|
|
|
*/
|
|
|
|
const std::vector<cmCommand*>& GetUsedCommands() const
|
2006-03-15 19:02:08 +03:00
|
|
|
{return this->UsedCommands;}
|
2001-02-27 01:58:54 +03:00
|
|
|
|
2006-03-22 17:58:11 +03:00
|
|
|
#if defined(CMAKE_BUILD_WITH_CMAKE)
|
2001-03-20 21:20:59 +03:00
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
*/
|
2007-08-24 22:21:49 +04:00
|
|
|
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; }
|
2001-10-26 23:42:02 +04:00
|
|
|
///! 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);}
|
2006-06-22 23:31:19 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the list file stack as a string
|
|
|
|
*/
|
|
|
|
std::string GetListFileStack();
|
|
|
|
|
2008-03-13 20:48:57 +03:00
|
|
|
/**
|
|
|
|
* Get the current context backtrace.
|
|
|
|
*/
|
|
|
|
bool GetBacktrace(cmListFileBacktrace& backtrace) const;
|
|
|
|
|
2006-04-10 21:53:00 +04:00
|
|
|
/**
|
|
|
|
* Get the vector of files created by this makefile
|
|
|
|
*/
|
|
|
|
const std::vector<std::string>& GetOutputFiles() const
|
|
|
|
{ return this->OutputFiles; }
|
|
|
|
void AddCMakeOutputFile(const char* file)
|
2006-04-11 18:04:55 +04:00
|
|
|
{ this->OutputFiles.push_back(file);}
|
2006-04-10 21:53:00 +04:00
|
|
|
|
2001-02-13 03:49:52 +03:00
|
|
|
/**
|
2003-02-14 17:54:15 +03:00
|
|
|
* Expand all defined variables in the string.
|
2006-03-15 19:02:08 +03:00
|
|
|
* Defined variables come from the this->Definitions map.
|
2001-02-13 03:49:52 +03:00
|
|
|
* They are expanded with ${var} where var is the
|
2006-03-15 19:02:08 +03:00
|
|
|
* entry in the this->Definitions map. Also @var@ is
|
2001-02-14 00:48:00 +03:00
|
|
|
* expanded to match autoconf style expansions.
|
2001-02-13 03:49:52 +03:00
|
|
|
*/
|
2007-06-07 00:20:02 +04:00
|
|
|
const char *ExpandVariablesInString(std::string& source);
|
2001-10-30 22:05:07 +03:00
|
|
|
const char *ExpandVariablesInString(std::string& source, bool escapeQuotes,
|
2005-06-17 23:50:08 +04:00
|
|
|
bool noEscapes,
|
2004-08-04 18:45:11 +04:00
|
|
|
bool atOnly = false,
|
|
|
|
const char* filename = 0,
|
2005-04-12 21:27:07 +04:00
|
|
|
long line = -1,
|
2006-10-04 22:37:42 +04:00
|
|
|
bool removeEmpty = false,
|
2007-06-07 00:20:02 +04:00
|
|
|
bool replaceAt = true);
|
2001-02-16 19:34:23 +03:00
|
|
|
|
2001-04-30 18:44:00 +04:00
|
|
|
/**
|
|
|
|
* Remove any remaining variables in the string. Anything with ${var} or
|
|
|
|
* @var@ will be removed.
|
|
|
|
*/
|
2006-05-12 20:29:09 +04:00
|
|
|
void RemoveVariablesInString(std::string& source,
|
|
|
|
bool atOnly = false) const;
|
2001-04-30 18:44:00 +04:00
|
|
|
|
2001-02-16 19:34:23 +03:00
|
|
|
/**
|
|
|
|
* Expand variables in the makefiles ivars such as link directories etc
|
|
|
|
*/
|
2001-03-20 21:20:59 +03:00
|
|
|
void ExpandVariables();
|
2004-03-04 02:18:47 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
int ConfigureFile(const char* infile, const char* outfile,
|
2005-07-13 19:21:30 +04:00
|
|
|
bool copyonly, bool atOnly, bool escapeQuotes);
|
2004-03-09 15:50:45 +03:00
|
|
|
|
2006-03-22 17:58:11 +03:00
|
|
|
#if defined(CMAKE_BUILD_WITH_CMAKE)
|
2001-04-11 22:59:02 +04:00
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
|
2001-07-26 00:53:13 +04:00
|
|
|
/**
|
2002-12-12 19:36:28 +03: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
|
|
|
*/
|
2008-01-23 18:28:26 +03:00
|
|
|
bool ExecuteCommand(const cmListFileFunction& lff,
|
|
|
|
cmExecutionStatus &status);
|
|
|
|
|
2001-12-18 17:39:26 +03:00
|
|
|
/** Check if a command exists. */
|
|
|
|
bool CommandExists(const char* name) const;
|
2001-07-26 00:53:13 +04:00
|
|
|
|
2002-09-11 00:52:39 +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.
|
2007-06-28 17:09:26 +04:00
|
|
|
void EnableLanguage(std::vector<std::string>const& languages, bool optional);
|
2002-05-02 00:33:27 +04:00
|
|
|
|
2002-08-28 22:51:10 +04:00
|
|
|
/**
|
|
|
|
* 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;
|
2004-10-27 18:47:14 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
2004-10-27 18:47:14 +04:00
|
|
|
#endif
|
2002-08-28 22:51:10 +04:00
|
|
|
|
2002-11-13 23:59:40 +03:00
|
|
|
///! Display progress or status message.
|
|
|
|
void DisplayStatus(const char*, float);
|
2002-12-12 02:13:33 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Expand the given list file arguments into the full set after
|
|
|
|
* variable replacement and list expansion.
|
|
|
|
*/
|
2008-09-24 16:51:33 +04:00
|
|
|
bool ExpandArguments(std::vector<cmListFileArgument> const& inArgs,
|
2002-12-12 02:13:33 +03:00
|
|
|
std::vector<std::string>& outArgs);
|
2003-01-21 00:59:02 +03:00
|
|
|
/**
|
|
|
|
* Get the instance
|
|
|
|
*/
|
|
|
|
cmake *GetCMakeInstance() const;
|
|
|
|
|
2003-06-03 18:30:23 +04:00
|
|
|
/**
|
|
|
|
* Get all the source files this makefile knows about
|
|
|
|
*/
|
|
|
|
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);
|
2003-08-07 02:54:13 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Add a macro to the list of macros. The arguments should be name of the
|
|
|
|
* macro and a documentation signature of it
|
|
|
|
*/
|
|
|
|
void AddMacro(const char* name, const char* signature);
|
|
|
|
|
2005-04-24 23:59:51 +04:00
|
|
|
///! 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;
|
|
|
|
|
2003-08-07 02:54:13 +04:00
|
|
|
/**
|
|
|
|
* Get a list of macros as a ; separated string
|
|
|
|
*/
|
|
|
|
void GetListOfMacros(std::string& macros);
|
2004-02-29 02:59:19 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Return a location of a file in cmake or custom modules directory
|
|
|
|
*/
|
|
|
|
std::string GetModulesFile(const char* name);
|
2004-04-23 20:52:48 +04:00
|
|
|
|
2004-05-21 00:56:34 +04:00
|
|
|
///! Set/Get a property of this directory
|
|
|
|
void SetProperty(const char *prop, const char *value);
|
2008-01-18 02:13:55 +03:00
|
|
|
void AppendProperty(const char *prop, const char *value);
|
2006-03-22 22:06:52 +03:00
|
|
|
const char *GetProperty(const char *prop);
|
2006-12-07 17:45:32 +03:00
|
|
|
const char *GetPropertyOrDefinition(const char *prop);
|
|
|
|
const char *GetProperty(const char *prop, cmProperty::ScopeType scope);
|
|
|
|
bool GetPropertyAsBool(const char *prop);
|
|
|
|
|
2009-10-02 21:52:01 +04:00
|
|
|
const char* GetFeature(const char* feature, const char* config);
|
|
|
|
|
2006-12-07 17:45:32 +03:00
|
|
|
// Get the properties
|
|
|
|
cmPropertyMap &GetProperties() { return this->Properties; };
|
2004-05-21 00:56:34 +04:00
|
|
|
|
2005-03-18 18:41:41 +03:00
|
|
|
///! Initialize a makefile from its parent
|
|
|
|
void InitializeFromParent();
|
|
|
|
|
|
|
|
///! 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; }
|
2006-02-10 21:54:36 +03:00
|
|
|
|
2006-02-19 23:25:27 +03:00
|
|
|
void AddInstallGenerator(cmInstallGenerator* g)
|
2007-06-16 00:07:16 +04:00
|
|
|
{ if(g) this->InstallGenerators.push_back(g); }
|
2006-02-19 23:25:27 +03:00
|
|
|
std::vector<cmInstallGenerator*>& GetInstallGenerators()
|
2006-03-15 19:02:08 +03:00
|
|
|
{ return this->InstallGenerators; }
|
2006-12-07 17:45:32 +03:00
|
|
|
|
2009-03-16 17:40:46 +03:00
|
|
|
void AddTestGenerator(cmTestGenerator* g)
|
|
|
|
{ if(g) this->TestGenerators.push_back(g); }
|
|
|
|
std::vector<cmTestGenerator*>& GetTestGenerators()
|
|
|
|
{ return this->TestGenerators; }
|
|
|
|
|
2006-12-07 17:45:32 +03:00
|
|
|
// 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();
|
2008-01-03 19:22:33 +03:00
|
|
|
void RaiseScope(const char *var, const char *value);
|
2007-12-03 21:35:41 +03:00
|
|
|
|
2009-01-14 23:14:06 +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;
|
2008-03-07 16:40:36 +03:00
|
|
|
|
2008-03-31 21:33:09 +04:00
|
|
|
/** Set whether or not to report a CMP0000 violation. */
|
|
|
|
void SetCheckCMP0000(bool b) { this->CheckCMP0000 = b; }
|
|
|
|
|
2000-08-29 23:26:29 +04:00
|
|
|
protected:
|
2002-05-02 23:56:13 +04:00
|
|
|
// add link libraries and directories to the target
|
|
|
|
void AddGlobalLinkInformation(const char* name, cmTarget& target);
|
|
|
|
|
2006-03-15 19:02:08 +03:00
|
|
|
std::string Prefix;
|
|
|
|
std::vector<std::string> AuxSourceDirectories; //
|
2001-02-15 21:30:13 +03:00
|
|
|
|
2006-03-15 19:02:08 +03:00
|
|
|
std::string cmStartDirectory;
|
|
|
|
std::string StartOutputDirectory;
|
|
|
|
std::string cmHomeDirectory;
|
|
|
|
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
|
2001-04-11 22:59:02 +04:00
|
|
|
|
|
|
|
// libraries, classes, and executables
|
2006-03-15 19:02:08 +03:00
|
|
|
cmTargets Targets;
|
|
|
|
std::vector<cmSourceFile*> SourceFiles;
|
2001-04-11 22:59:02 +04:00
|
|
|
|
2005-04-24 23:59:51 +04:00
|
|
|
// Tests
|
2009-01-05 23:00:57 +03:00
|
|
|
std::map<cmStdString, cmTest*> Tests;
|
2005-07-07 19:44:36 +04:00
|
|
|
|
2001-07-30 19:34:03 +04:00
|
|
|
// The include and link-library paths. These may have order
|
|
|
|
// dependency, so they must be vectors (not set).
|
2006-03-15 19:02:08 +03:00
|
|
|
std::vector<std::string> IncludeDirectories;
|
|
|
|
std::vector<std::string> LinkDirectories;
|
2006-10-05 16:55:59 +04:00
|
|
|
|
|
|
|
// 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
|
2006-04-10 21:53:00 +04:00
|
|
|
std::vector<std::string> OutputFiles; // list of command files loaded
|
2001-06-06 04:34:01 +04:00
|
|
|
|
|
|
|
|
2006-03-15 19:02:08 +03:00
|
|
|
cmTarget::LinkLibraryVectorType LinkLibraries;
|
|
|
|
|
|
|
|
std::vector<cmInstallGenerator*> InstallGenerators;
|
2009-03-16 17:40:46 +03:00
|
|
|
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
|
|
|
|
2008-06-26 21:30:10 +04: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
|
|
|
|
|
2006-03-15 19:02:08 +03:00
|
|
|
std::vector<cmCommand*> UsedCommands;
|
|
|
|
cmLocalGenerator* LocalGenerator;
|
2008-01-23 18:28:26 +03:00
|
|
|
bool IsFunctionBlocked(const cmListFileFunction& lff,
|
|
|
|
cmExecutionStatus &status);
|
2001-04-11 22:59:02 +04:00
|
|
|
|
2001-01-11 22:47:38 +03:00
|
|
|
private:
|
2007-06-11 18:25:40 +04:00
|
|
|
void Initialize();
|
2001-01-11 22:47:38 +03:00
|
|
|
|
2008-01-18 03:29:43 +03:00
|
|
|
bool ParseDefineFlag(std::string const& definition, bool remove);
|
|
|
|
|
2009-06-17 21:40:09 +04:00
|
|
|
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
|
|
|
|
// to the Sources array
|
2006-03-10 19:13:15 +03:00
|
|
|
void PrintStringVector(const char* s, const
|
|
|
|
std::vector<std::pair<cmStdString, bool> >& v) const;
|
|
|
|
void PrintStringVector(const char* s,
|
|
|
|
const std::vector<std::string>& v) const;
|
2006-03-15 19:02:08 +03:00
|
|
|
|
2001-03-08 18:30:18 +03:00
|
|
|
void AddDefaultDefinitions();
|
2009-01-21 17:48:00 +03:00
|
|
|
typedef std::vector<cmFunctionBlocker*> FunctionBlockersType;
|
|
|
|
FunctionBlockersType FunctionBlockers;
|
|
|
|
std::vector<FunctionBlockersType::size_type> FunctionBlockerBarriers;
|
|
|
|
void PushFunctionBlockerBarrier();
|
|
|
|
void PopFunctionBlockerBarrier(bool reportError = true);
|
2003-01-14 17:53:13 +03:00
|
|
|
|
2003-08-07 02:54:13 +04:00
|
|
|
typedef std::map<cmStdString, cmStdString> StringStringMap;
|
2006-03-15 19:02:08 +03:00
|
|
|
StringStringMap MacrosMap;
|
2003-08-07 02:54:13 +04:00
|
|
|
|
2006-03-15 19:02:08 +03:00
|
|
|
std::map<cmStdString, bool> SubDirectoryOrder;
|
2004-03-04 02:18:47 +03:00
|
|
|
|
2006-03-15 19:02:08 +03:00
|
|
|
cmsys::RegularExpression cmDefineRegex;
|
|
|
|
cmsys::RegularExpression cmDefine01Regex;
|
2007-06-07 00:20:02 +04:00
|
|
|
cmsys::RegularExpression cmAtVarRegex;
|
2004-05-21 00:56:34 +04:00
|
|
|
|
2006-12-07 17:45:32 +03:00
|
|
|
cmPropertyMap Properties;
|
2005-03-18 18:41:41 +03:00
|
|
|
|
|
|
|
// 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
|
|
|
|
2006-03-22 22:06:52 +03:00
|
|
|
// stack of list files being read
|
|
|
|
std::deque<cmStdString> ListFileStack;
|
2008-01-28 16:38:36 +03:00
|
|
|
|
2008-03-07 16:40:36 +03:00
|
|
|
// stack of commands being invoked.
|
|
|
|
struct CallStackEntry
|
|
|
|
{
|
|
|
|
cmListFileContext const* Context;
|
|
|
|
cmExecutionStatus* Status;
|
|
|
|
};
|
|
|
|
typedef std::deque<CallStackEntry> CallStackType;
|
|
|
|
CallStackType CallStack;
|
|
|
|
friend class cmMakefileCall;
|
|
|
|
|
2008-01-28 16:38:36 +03:00
|
|
|
cmTarget* FindBasicTarget(const char* name);
|
|
|
|
std::vector<cmTarget*> ImportedTargetsOwned;
|
|
|
|
std::map<cmStdString, cmTarget*> ImportedTargets;
|
2009-01-22 18:57:09 +03:00
|
|
|
|
|
|
|
// Internal policy stack management.
|
2009-01-22 21:16:27 +03:00
|
|
|
void PushPolicy(bool weak = false,
|
|
|
|
cmPolicies::PolicyMap const& pm = cmPolicies::PolicyMap());
|
2009-01-22 18:57:16 +03:00
|
|
|
void PopPolicy();
|
|
|
|
void PushPolicyBarrier();
|
|
|
|
void PopPolicyBarrier(bool reportError = true);
|
2009-01-22 18:57:09 +03:00
|
|
|
friend class cmCMakePolicyCommand;
|
2009-01-22 18:57:16 +03:00
|
|
|
class IncludeScope;
|
|
|
|
friend class IncludeScope;
|
2009-01-22 18:57:09 +03:00
|
|
|
|
2008-03-01 23:20:35 +03:00
|
|
|
// stack of policy settings
|
2009-01-22 18:56:39 +03:00
|
|
|
struct PolicyStackEntry: public cmPolicies::PolicyMap
|
|
|
|
{
|
|
|
|
typedef cmPolicies::PolicyMap derived;
|
2009-01-22 21:16:27 +03:00
|
|
|
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;
|
2009-01-22 18:56:39 +03:00
|
|
|
};
|
|
|
|
typedef std::vector<PolicyStackEntry> PolicyStackType;
|
|
|
|
PolicyStackType PolicyStack;
|
2009-01-22 18:57:16 +03:00
|
|
|
std::vector<PolicyStackType::size_type> PolicyBarriers;
|
2008-08-19 00:29:00 +04:00
|
|
|
cmPolicies::PolicyStatus GetPolicyStatusInternal(cmPolicies::PolicyID id);
|
2008-03-31 21:33:09 +04:00
|
|
|
|
|
|
|
bool CheckCMP0000;
|
|
|
|
|
|
|
|
// Enforce rules about CMakeLists.txt files.
|
2009-01-15 22:37:14 +03:00
|
|
|
void EnforceDirectoryLevelRules();
|
2000-08-29 23:26:29 +04:00
|
|
|
};
|
|
|
|
|
2009-01-20 22:35:22 +03:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
// 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;
|
|
|
|
};
|
2000-08-29 23:26:29 +04:00
|
|
|
|
|
|
|
#endif
|