2009-09-28 15:43:28 +00:00
|
|
|
/*============================================================================
|
|
|
|
CMake - Cross Platform Makefile Generator
|
|
|
|
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
|
2001-05-18 19:25:08 +00:00
|
|
|
|
2009-09-28 15:43:28 +00:00
|
|
|
Distributed under the OSI-approved BSD License (the "License");
|
|
|
|
see accompanying file Copyright.txt for details.
|
2001-05-18 19:25:08 +00:00
|
|
|
|
2009-09-28 15:43:28 +00:00
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even the
|
|
|
|
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the License for more information.
|
|
|
|
============================================================================*/
|
2002-08-28 18:51:10 +00:00
|
|
|
// This class represents a cmake invocation. It is the top level class when
|
|
|
|
// running cmake. Most cmake based GUIS should primarily create an instance
|
|
|
|
// of this class and communicate with it.
|
2002-09-17 18:12:03 +00:00
|
|
|
//
|
|
|
|
// The basic process for a GUI is as follows:
|
|
|
|
//
|
|
|
|
// 1) Create a cmake instance
|
|
|
|
// 2) Set the Home & Start directories, generator, and cmake command. this
|
|
|
|
// can be done using the Set methods or by using SetArgs and passing in
|
|
|
|
// command line arguments.
|
|
|
|
// 3) Load the cache by calling LoadCache (duh)
|
|
|
|
// 4) if you are using command line arguments with -D or -C flags then
|
|
|
|
// call SetCacheArgs (or if for some other reason you want to modify the
|
|
|
|
// cache, do it now.
|
|
|
|
// 5) Finally call Configure
|
|
|
|
// 6) Let the user change values and go back to step 5
|
|
|
|
// 7) call Generate
|
|
|
|
//
|
|
|
|
// If your GUI allows the user to change the start & home directories then
|
|
|
|
// you must at a minimum redo steps 2 through 7.
|
|
|
|
//
|
|
|
|
|
2001-05-18 19:25:08 +00:00
|
|
|
|
2004-10-04 16:31:09 +00:00
|
|
|
#ifndef cmake_h
|
|
|
|
#define cmake_h
|
|
|
|
|
2002-09-06 17:06:23 +00:00
|
|
|
#include "cmSystemTools.h"
|
2006-12-07 14:45:32 +00:00
|
|
|
#include "cmPropertyDefinitionMap.h"
|
|
|
|
#include "cmPropertyMap.h"
|
2002-09-06 17:06:23 +00:00
|
|
|
|
|
|
|
class cmGlobalGenerator;
|
|
|
|
class cmLocalGenerator;
|
|
|
|
class cmCacheManager;
|
|
|
|
class cmMakefile;
|
2002-09-10 20:51:29 +00:00
|
|
|
class cmCommand;
|
2003-01-08 17:59:52 +00:00
|
|
|
class cmVariableWatch;
|
2005-10-12 17:51:15 +00:00
|
|
|
class cmFileTimeComparison;
|
2007-06-08 15:57:16 +00:00
|
|
|
class cmExternalMakefileProjectGenerator;
|
2007-10-22 16:49:09 +00:00
|
|
|
class cmDocumentationSection;
|
2008-03-01 20:20:35 +00:00
|
|
|
class cmPolicies;
|
2008-03-13 17:48:57 +00:00
|
|
|
class cmListFileBacktrace;
|
2001-05-18 19:25:08 +00:00
|
|
|
|
2002-08-23 20:13:34 +00:00
|
|
|
class cmake
|
2001-05-18 19:25:08 +00:00
|
|
|
{
|
|
|
|
public:
|
2008-03-11 14:29:56 +00:00
|
|
|
enum MessageType
|
|
|
|
{ AUTHOR_WARNING,
|
|
|
|
FATAL_ERROR,
|
2008-03-13 01:06:32 +00:00
|
|
|
INTERNAL_ERROR,
|
2008-03-11 14:29:56 +00:00
|
|
|
MESSAGE,
|
|
|
|
WARNING,
|
|
|
|
LOG
|
|
|
|
};
|
2003-08-04 00:47:44 +00:00
|
|
|
typedef std::map<cmStdString, cmCommand*> RegisteredCommandsMap;
|
|
|
|
|
2002-09-06 17:06:23 +00:00
|
|
|
///! construct an instance of cmake
|
|
|
|
cmake();
|
|
|
|
///! destruct an instance of cmake
|
|
|
|
~cmake();
|
2001-05-18 19:25:08 +00:00
|
|
|
|
2006-06-14 16:28:32 +00:00
|
|
|
///! construct an instance of cmake
|
|
|
|
static const char *GetCMakeFilesDirectory() {return "/CMakeFiles";};
|
2006-06-15 15:51:51 +00:00
|
|
|
static const char *GetCMakeFilesDirectoryPostSlash() {
|
|
|
|
return "CMakeFiles/";};
|
2006-06-14 16:28:32 +00:00
|
|
|
|
2002-09-06 17:06:23 +00: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
|
|
|
|
* cmake 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.
|
|
|
|
*/
|
|
|
|
void SetHomeDirectory(const char* dir);
|
|
|
|
const char* GetHomeDirectory() const
|
|
|
|
{
|
2006-03-15 16:02:08 +00:00
|
|
|
return this->cmHomeDirectory.c_str();
|
2002-09-06 17:06:23 +00:00
|
|
|
}
|
|
|
|
void SetHomeOutputDirectory(const char* lib);
|
|
|
|
const char* GetHomeOutputDirectory() const
|
|
|
|
{
|
2006-03-15 16:02:08 +00:00
|
|
|
return this->HomeOutputDirectory.c_str();
|
2002-09-06 17:06:23 +00: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.
|
|
|
|
*/
|
|
|
|
void SetStartDirectory(const char* dir)
|
|
|
|
{
|
2006-03-15 16:02:08 +00:00
|
|
|
this->cmStartDirectory = dir;
|
|
|
|
cmSystemTools::ConvertToUnixSlashes(this->cmStartDirectory);
|
2002-09-06 17:06:23 +00:00
|
|
|
}
|
|
|
|
const char* GetStartDirectory() const
|
|
|
|
{
|
2006-03-15 16:02:08 +00:00
|
|
|
return this->cmStartDirectory.c_str();
|
2002-09-06 17:06:23 +00:00
|
|
|
}
|
|
|
|
void SetStartOutputDirectory(const char* lib)
|
|
|
|
{
|
2006-03-15 16:02:08 +00:00
|
|
|
this->StartOutputDirectory = lib;
|
|
|
|
cmSystemTools::ConvertToUnixSlashes(this->StartOutputDirectory);
|
2002-09-06 17:06:23 +00:00
|
|
|
}
|
|
|
|
const char* GetStartOutputDirectory() const
|
|
|
|
{
|
2006-03-15 16:02:08 +00:00
|
|
|
return this->StartOutputDirectory.c_str();
|
2002-09-06 17:06:23 +00:00
|
|
|
}
|
|
|
|
//@}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Handle a command line invocation of cmake.
|
|
|
|
*/
|
2003-04-29 14:04:05 +00:00
|
|
|
int Run(const std::vector<std::string>&args)
|
2003-04-30 11:32:30 +00:00
|
|
|
{ return this->Run(args, false); }
|
2003-04-29 14:04:05 +00:00
|
|
|
int Run(const std::vector<std::string>&args, bool noconfigure);
|
2001-05-18 19:25:08 +00:00
|
|
|
|
|
|
|
/**
|
2007-05-28 16:23:32 +00:00
|
|
|
* Run the global generator Generate step.
|
2001-05-18 19:25:08 +00:00
|
|
|
*/
|
2002-09-06 17:06:23 +00:00
|
|
|
int Generate();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Configure the cmMakefiles. This routine will create a GlobalGenerator if
|
|
|
|
* one has not already been set. It will then Call Configure on the
|
|
|
|
* GlobalGenerator. This in turn will read in an process all the CMakeList
|
|
|
|
* files for the tree. It will not produce any actual Makefiles, or
|
|
|
|
* workspaces. Generate does that. */
|
2002-09-17 17:59:58 +00:00
|
|
|
int Configure();
|
2007-12-13 20:54:29 +00:00
|
|
|
int ActualConfigure();
|
2002-09-17 17:59:58 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Configure the cmMakefiles. This routine will create a GlobalGenerator if
|
|
|
|
* one has not already been set. It will then Call Configure on the
|
|
|
|
* GlobalGenerator. This in turn will read in an process all the CMakeList
|
|
|
|
* files for the tree. It will not produce any actual Makefiles, or
|
|
|
|
* workspaces. Generate does that. */
|
2002-11-07 14:04:20 +00:00
|
|
|
int LoadCache();
|
2004-08-17 19:36:08 +00:00
|
|
|
void PreLoadCMakeFiles();
|
2002-09-06 17:06:23 +00:00
|
|
|
|
|
|
|
///! Create a GlobalGenerator
|
|
|
|
cmGlobalGenerator* CreateGlobalGenerator(const char* name);
|
|
|
|
|
|
|
|
///! Return the global generator assigned to this instance of cmake
|
2007-06-15 14:10:24 +00:00
|
|
|
cmGlobalGenerator* GetGlobalGenerator() { return this->GlobalGenerator; }
|
|
|
|
///! Return the global generator assigned to this instance of cmake, const
|
|
|
|
const cmGlobalGenerator* GetGlobalGenerator() const
|
|
|
|
{ return this->GlobalGenerator; }
|
2002-09-06 17:06:23 +00:00
|
|
|
|
|
|
|
///! Return the global generator assigned to this instance of cmake
|
|
|
|
void SetGlobalGenerator(cmGlobalGenerator *);
|
|
|
|
|
|
|
|
///! Get the names of the current registered generators
|
|
|
|
void GetRegisteredGenerators(std::vector<std::string>& names);
|
|
|
|
|
|
|
|
///! get the cmCachemManager used by this invocation of cmake
|
2006-03-15 16:02:08 +00:00
|
|
|
cmCacheManager *GetCacheManager() { return this->CacheManager; }
|
2002-09-06 17:06:23 +00:00
|
|
|
|
2002-09-17 17:59:58 +00:00
|
|
|
///! set the cmake command this instance of cmake should use
|
2006-03-15 16:02:08 +00:00
|
|
|
void SetCMakeCommand(const char* cmd) { this->CMakeCommand = cmd; }
|
2002-09-17 17:59:58 +00:00
|
|
|
|
2002-09-06 17:06:23 +00:00
|
|
|
/**
|
|
|
|
* Given a variable name, return its value (as a string).
|
|
|
|
*/
|
|
|
|
const char* GetCacheDefinition(const char*) const;
|
2002-12-04 15:57:22 +00:00
|
|
|
///! Add an entry into the cache
|
|
|
|
void AddCacheEntry(const char* key, const char* value,
|
|
|
|
const char* helpString,
|
|
|
|
int type);
|
2002-06-03 17:08:52 +00:00
|
|
|
/**
|
|
|
|
* Execute commands during the build process. Supports options such
|
|
|
|
* as echo, remove file etc.
|
|
|
|
*/
|
2006-03-15 16:02:08 +00:00
|
|
|
static int ExecuteCMakeCommand(std::vector<std::string>&);
|
2002-06-03 17:08:52 +00:00
|
|
|
|
2007-02-27 15:10:10 +00:00
|
|
|
/**
|
|
|
|
* Get the system information and write it to the file specified
|
|
|
|
*/
|
|
|
|
int GetSystemInformation(std::vector<std::string>&);
|
|
|
|
|
2002-09-10 20:51:29 +00:00
|
|
|
/**
|
|
|
|
* Add a command to this cmake instance
|
|
|
|
*/
|
|
|
|
void AddCommand(cmCommand* );
|
2005-06-14 16:48:59 +00:00
|
|
|
void RenameCommand(const char* oldName, const char* newName);
|
2007-06-12 14:56:40 +00:00
|
|
|
void RemoveCommand(const char* name);
|
2007-07-27 12:59:59 +00:00
|
|
|
void RemoveUnscriptableCommands();
|
2002-09-10 20:51:29 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get a command by its name
|
|
|
|
*/
|
|
|
|
cmCommand *GetCommand(const char *name);
|
|
|
|
|
2003-08-04 00:47:44 +00:00
|
|
|
/** Get list of all commands */
|
2006-03-15 16:02:08 +00:00
|
|
|
RegisteredCommandsMap* GetCommands() { return &this->Commands; }
|
2003-08-04 00:47:44 +00:00
|
|
|
|
2002-09-10 20:51:29 +00:00
|
|
|
/** Check if a command exists. */
|
|
|
|
bool CommandExists(const char* name) const;
|
|
|
|
|
2001-11-20 22:51:03 +00:00
|
|
|
///! Parse command line arguments
|
2002-09-06 17:06:23 +00:00
|
|
|
void SetArgs(const std::vector<std::string>&);
|
|
|
|
|
2002-09-12 15:08:06 +00:00
|
|
|
///! Is this cmake running as a result of a TRY_COMPILE command
|
2006-03-15 16:02:08 +00:00
|
|
|
bool GetIsInTryCompile() { return this->InTryCompile; }
|
2002-09-12 15:08:06 +00:00
|
|
|
|
|
|
|
///! Is this cmake running as a result of a TRY_COMPILE command
|
2006-03-15 16:02:08 +00:00
|
|
|
void SetIsInTryCompile(bool i) { this->InTryCompile = i; }
|
2002-09-12 15:08:06 +00:00
|
|
|
|
2002-09-17 17:59:58 +00:00
|
|
|
///! Parse command line arguments that might set cache values
|
2003-10-29 14:45:26 +00:00
|
|
|
bool SetCacheArgs(const std::vector<std::string>&);
|
2002-09-13 17:48:14 +00:00
|
|
|
|
2006-03-15 16:02:08 +00:00
|
|
|
typedef void (*ProgressCallbackType)
|
|
|
|
(const char*msg, float progress, void *);
|
2002-09-26 19:14:20 +00:00
|
|
|
/**
|
|
|
|
* Set the function used by GUI's to receive progress updates
|
|
|
|
* Function gets passed: message as a const char*, a progress
|
|
|
|
* amount ranging from 0 to 1.0 and client data. The progress
|
|
|
|
* number provided may be negative in cases where a message is
|
|
|
|
* to be displayed without any progress percentage.
|
|
|
|
*/
|
2006-03-15 16:02:08 +00:00
|
|
|
void SetProgressCallback(ProgressCallbackType f, void* clientData=0);
|
2002-09-26 19:14:20 +00:00
|
|
|
|
|
|
|
///! this is called by generators to update the progress
|
|
|
|
void UpdateProgress(const char *msg, float prog);
|
|
|
|
|
2008-03-01 20:20:35 +00:00
|
|
|
///! get the cmake policies instance
|
|
|
|
cmPolicies *GetPolicies() {return this->Policies;} ;
|
2003-01-08 17:59:52 +00:00
|
|
|
|
|
|
|
///! Get the variable watch object
|
2006-03-15 16:02:08 +00:00
|
|
|
cmVariableWatch* GetVariableWatch() { return this->VariableWatch; }
|
2003-01-08 17:59:52 +00:00
|
|
|
|
2007-06-22 12:44:51 +00:00
|
|
|
/** Get the documentation entries for the supported commands.
|
|
|
|
* If withCurrentCommands is true, the documentation for the
|
|
|
|
* recommended set of commands is included.
|
|
|
|
* If withCompatCommands is true, the documentation for discouraged
|
|
|
|
* (compatibility) commands is included.
|
|
|
|
* You probably don't want to set both to false.
|
|
|
|
*/
|
|
|
|
void GetCommandDocumentation(std::vector<cmDocumentationEntry>& entries,
|
|
|
|
bool withCurrentCommands = true,
|
|
|
|
bool withCompatCommands = true) const;
|
2007-10-22 16:49:09 +00:00
|
|
|
void GetPropertiesDocumentation(std::map<std::string,
|
|
|
|
cmDocumentationSection *>&);
|
2003-07-08 01:52:10 +00:00
|
|
|
void GetGeneratorDocumentation(std::vector<cmDocumentationEntry>&);
|
2008-03-04 14:16:33 +00:00
|
|
|
void GetPolicyDocumentation(std::vector<cmDocumentationEntry>& entries);
|
2003-05-29 15:14:05 +00:00
|
|
|
|
2006-12-07 14:45:32 +00:00
|
|
|
///! Set/Get a property of this target file
|
|
|
|
void SetProperty(const char *prop, const char *value);
|
2008-01-17 23:13:55 +00:00
|
|
|
void AppendProperty(const char *prop, const char *value);
|
2006-12-07 14:45:32 +00:00
|
|
|
const char *GetProperty(const char *prop);
|
|
|
|
const char *GetProperty(const char *prop, cmProperty::ScopeType scope);
|
|
|
|
bool GetPropertyAsBool(const char *prop);
|
|
|
|
|
|
|
|
// Get the properties
|
|
|
|
cmPropertyMap &GetProperties() { return this->Properties; };
|
|
|
|
|
2003-05-29 15:14:05 +00:00
|
|
|
///! Do all the checks before running configure
|
|
|
|
int DoPreConfigureChecks();
|
2003-10-29 14:45:26 +00:00
|
|
|
|
|
|
|
/**
|
2006-05-12 18:36:39 +00:00
|
|
|
* Set and get the script mode option. In script mode there is no
|
|
|
|
* generator and no cache. Also, language are not enabled, so
|
|
|
|
* add_executable and things do not do anything.
|
2003-10-29 14:45:26 +00:00
|
|
|
*/
|
2006-03-15 16:02:08 +00:00
|
|
|
void SetScriptMode(bool mode) { this->ScriptMode = mode; }
|
|
|
|
bool GetScriptMode() { return this->ScriptMode; }
|
2003-02-14 15:53:37 +00:00
|
|
|
|
2003-12-23 20:01:10 +00:00
|
|
|
///! Debug the try compile stuff by not delelting the files
|
2006-03-15 16:02:08 +00:00
|
|
|
bool GetDebugTryCompile(){return this->DebugTryCompile;}
|
|
|
|
void DebugTryCompileOn(){this->DebugTryCompile = true;}
|
2004-04-18 18:41:46 +00:00
|
|
|
|
2005-05-02 19:51:12 +00:00
|
|
|
/**
|
|
|
|
* Generate CMAKE_ROOT and CMAKE_COMMAND cache entries
|
|
|
|
*/
|
2007-12-13 22:56:50 +00:00
|
|
|
int AddCMakePaths();
|
2005-05-02 19:51:12 +00:00
|
|
|
|
2005-10-12 17:51:15 +00:00
|
|
|
/**
|
|
|
|
* Get the file comparison class
|
|
|
|
*/
|
2006-03-15 16:02:08 +00:00
|
|
|
cmFileTimeComparison* GetFileComparison() { return this->FileComparison; }
|
2005-10-12 17:51:15 +00:00
|
|
|
|
2006-02-23 15:00:44 +00:00
|
|
|
/**
|
|
|
|
* Get the path to ctest
|
|
|
|
*/
|
|
|
|
const char* GetCTestCommand();
|
|
|
|
const char* GetCPackCommand();
|
|
|
|
|
2006-10-06 15:11:59 +00:00
|
|
|
// Do we want debug output during the cmake run.
|
|
|
|
bool GetDebugOutput() { return this->DebugOutput; }
|
2008-04-02 21:29:25 +00:00
|
|
|
void SetDebugOutputOn(bool b) { this->DebugOutput = b;}
|
2006-10-30 20:59:54 +00:00
|
|
|
|
2008-07-31 14:33:25 +00:00
|
|
|
// Do we want trace output during the cmake run.
|
|
|
|
bool GetTrace() { return this->Trace;}
|
|
|
|
void SetTrace(bool b) { this->Trace = b;}
|
2010-08-25 16:35:40 +00:00
|
|
|
bool GetWarnUninitialized() { return this->WarnUninitialized;}
|
|
|
|
void SetWarnUninitialized(bool b) { this->WarnUninitialized = b;}
|
2010-08-25 16:36:21 +00:00
|
|
|
bool GetWarnUnused() { return this->WarnUnused;}
|
|
|
|
void SetWarnUnused(bool b) { this->WarnUnused = b;}
|
2010-08-24 20:49:49 +00:00
|
|
|
bool GetDefaultToUsed() { return this->DefaultToUsed;}
|
|
|
|
void SetDefaultToUsed(bool b) { this->DefaultToUsed = b;}
|
2006-12-07 14:45:32 +00:00
|
|
|
// Define a property
|
|
|
|
void DefineProperty(const char *name, cmProperty::ScopeType scope,
|
|
|
|
const char *ShortDescription,
|
|
|
|
const char *FullDescription,
|
2007-10-22 16:49:09 +00:00
|
|
|
bool chain = false,
|
|
|
|
const char *variableGroup = 0);
|
2006-12-07 14:45:32 +00:00
|
|
|
|
2007-10-24 18:43:10 +00:00
|
|
|
// get property definition
|
|
|
|
cmPropertyDefinition *GetPropertyDefinition
|
|
|
|
(const char *name, cmProperty::ScopeType scope);
|
|
|
|
|
2006-12-07 14:45:32 +00:00
|
|
|
// Is a property defined?
|
|
|
|
bool IsPropertyDefined(const char *name, cmProperty::ScopeType scope);
|
|
|
|
bool IsPropertyChained(const char *name, cmProperty::ScopeType scope);
|
|
|
|
|
2008-09-04 21:34:25 +00:00
|
|
|
/** Get the list of configurations (in upper case) considered to be
|
|
|
|
debugging configurations.*/
|
|
|
|
std::vector<std::string> const& GetDebugConfigs();
|
|
|
|
|
2007-11-06 19:16:00 +00:00
|
|
|
// record accesses of properties and variables
|
|
|
|
void RecordPropertyAccess(const char *name, cmProperty::ScopeType scope);
|
|
|
|
void ReportUndefinedPropertyAccesses(const char *filename);
|
|
|
|
|
2007-06-26 17:05:27 +00:00
|
|
|
// Define the properties
|
|
|
|
static void DefineProperties(cmake *cm);
|
|
|
|
|
2008-02-12 14:49:42 +00:00
|
|
|
void SetCMakeEditCommand(const char* s)
|
|
|
|
{
|
|
|
|
this->CMakeEditCommand = s;
|
|
|
|
}
|
2008-03-12 02:50:35 +00:00
|
|
|
void SetSuppressDevWarnings(bool v)
|
|
|
|
{
|
2008-03-29 17:16:02 +00:00
|
|
|
this->SuppressDevWarnings = v;
|
|
|
|
this->DoSuppressDevWarnings = true;
|
2008-03-12 02:50:35 +00:00
|
|
|
}
|
2008-03-13 17:48:57 +00:00
|
|
|
|
|
|
|
/** Display a message to the user. */
|
|
|
|
void IssueMessage(cmake::MessageType t, std::string const& text,
|
|
|
|
cmListFileBacktrace const& backtrace);
|
2008-10-15 17:56:07 +00:00
|
|
|
// * run the --build option
|
|
|
|
int Build(const std::string& dir,
|
|
|
|
const std::string& target,
|
|
|
|
const std::string& config,
|
2009-03-04 20:39:27 +00:00
|
|
|
const std::vector<std::string>& nativeOptions,
|
2008-10-15 17:56:07 +00:00
|
|
|
bool clean);
|
2009-03-04 20:39:27 +00:00
|
|
|
protected:
|
2008-03-12 21:02:30 +00:00
|
|
|
void InitializeProperties();
|
2007-12-13 20:54:29 +00:00
|
|
|
int HandleDeleteCacheVariables(const char* var);
|
2006-12-07 14:45:32 +00:00
|
|
|
cmPropertyMap Properties;
|
2007-11-06 19:16:00 +00:00
|
|
|
std::set<std::pair<cmStdString,cmProperty::ScopeType> > AccessedProperties;
|
2007-06-25 14:34:21 +00:00
|
|
|
|
|
|
|
std::map<cmProperty::ScopeType, cmPropertyDefinitionMap>
|
|
|
|
PropertyDefinitions;
|
2007-06-08 15:57:16 +00:00
|
|
|
|
|
|
|
typedef
|
|
|
|
cmExternalMakefileProjectGenerator* (*CreateExtraGeneratorFunctionType)();
|
|
|
|
typedef std::map<cmStdString,
|
|
|
|
CreateExtraGeneratorFunctionType> RegisteredExtraGeneratorsMap;
|
|
|
|
|
2003-07-08 01:52:10 +00:00
|
|
|
typedef cmGlobalGenerator* (*CreateGeneratorFunctionType)();
|
2006-03-10 16:13:15 +00:00
|
|
|
typedef std::map<cmStdString,
|
|
|
|
CreateGeneratorFunctionType> RegisteredGeneratorsMap;
|
2006-03-15 16:02:08 +00:00
|
|
|
RegisteredCommandsMap Commands;
|
|
|
|
RegisteredGeneratorsMap Generators;
|
2007-06-08 15:57:16 +00:00
|
|
|
RegisteredExtraGeneratorsMap ExtraGenerators;
|
2002-09-10 20:51:29 +00:00
|
|
|
void AddDefaultCommands();
|
2003-07-08 01:52:10 +00:00
|
|
|
void AddDefaultGenerators();
|
2007-06-08 15:57:16 +00:00
|
|
|
void AddDefaultExtraGenerators();
|
2007-07-20 12:36:16 +00:00
|
|
|
void AddExtraGenerator(const char* name,
|
|
|
|
CreateExtraGeneratorFunctionType newFunction);
|
2002-09-10 20:51:29 +00:00
|
|
|
|
2008-03-01 20:20:35 +00:00
|
|
|
cmPolicies *Policies;
|
2006-03-15 16:02:08 +00:00
|
|
|
cmGlobalGenerator *GlobalGenerator;
|
|
|
|
cmCacheManager *CacheManager;
|
|
|
|
std::string cmHomeDirectory;
|
|
|
|
std::string HomeOutputDirectory;
|
|
|
|
std::string cmStartDirectory;
|
|
|
|
std::string StartOutputDirectory;
|
2008-03-12 02:50:35 +00:00
|
|
|
bool SuppressDevWarnings;
|
2008-03-22 14:24:06 +00:00
|
|
|
bool DoSuppressDevWarnings;
|
2004-04-18 18:41:46 +00:00
|
|
|
|
2002-09-06 17:06:23 +00:00
|
|
|
///! read in a cmake list file to initialize the cache
|
|
|
|
void ReadListFile(const char *path);
|
2005-07-03 02:25:43 +00:00
|
|
|
|
|
|
|
///! Check if CMAKE_CACHEFILE_DIR is set. If it is not, delete the log file.
|
|
|
|
/// If it is set, truncate it to 50kb
|
|
|
|
void TruncateOutputLog(const char* fname);
|
2002-09-06 17:06:23 +00:00
|
|
|
|
2004-10-29 20:50:46 +00:00
|
|
|
/**
|
|
|
|
* Method called to check build system integrity at build time.
|
|
|
|
* Returns 1 if CMake should rerun and 0 otherwise.
|
|
|
|
*/
|
|
|
|
int CheckBuildSystem();
|
2002-08-28 18:51:10 +00:00
|
|
|
|
2003-08-05 20:36:15 +00:00
|
|
|
void SetDirectoriesFromFile(const char* arg);
|
2005-06-16 18:56:15 +00:00
|
|
|
|
2006-05-12 18:36:39 +00:00
|
|
|
//! Make sure all commands are what they say they are and there is no
|
|
|
|
//macros.
|
2005-06-16 18:56:15 +00:00
|
|
|
void CleanupCommandsAndMacros();
|
2006-03-03 19:24:31 +00:00
|
|
|
|
2007-06-15 14:10:24 +00:00
|
|
|
void GenerateGraphViz(const char* fileName) const;
|
2006-04-27 01:31:39 +00:00
|
|
|
|
2009-10-21 17:10:24 +00:00
|
|
|
static int SymlinkLibrary(std::vector<std::string>& args);
|
|
|
|
static int SymlinkExecutable(std::vector<std::string>& args);
|
|
|
|
static bool SymlinkInternal(std::string const& file,
|
|
|
|
std::string const& link);
|
2006-04-27 01:31:39 +00:00
|
|
|
static int ExecuteEchoColor(std::vector<std::string>& args);
|
2006-06-15 20:17:11 +00:00
|
|
|
static int ExecuteLinkScript(std::vector<std::string>& args);
|
2008-01-01 20:13:41 +00:00
|
|
|
static int VisualStudioLink(std::vector<std::string>& args, int type);
|
|
|
|
static int VisualStudioLinkIncremental(std::vector<std::string>& args,
|
|
|
|
int type,
|
|
|
|
bool verbose);
|
|
|
|
static int VisualStudioLinkNonIncremental(std::vector<std::string>& args,
|
|
|
|
int type,
|
2008-06-20 20:25:02 +00:00
|
|
|
bool hasManifest,
|
2008-01-01 20:13:41 +00:00
|
|
|
bool verbose);
|
|
|
|
static int ParseVisualStudioLinkCommand(std::vector<std::string>& args,
|
|
|
|
std::vector<cmStdString>& command,
|
|
|
|
std::string& targetName);
|
|
|
|
static bool RunCommand(const char* comment,
|
|
|
|
std::vector<cmStdString>& command,
|
|
|
|
bool verbose,
|
|
|
|
int* retCodeOut = 0);
|
2006-03-15 16:02:08 +00:00
|
|
|
cmVariableWatch* VariableWatch;
|
2006-10-06 15:11:59 +00:00
|
|
|
|
2007-06-15 14:10:24 +00:00
|
|
|
///! Find the full path to one of the cmake programs like ctest, cpack, etc.
|
|
|
|
std::string FindCMakeProgram(const char* name) const;
|
2008-06-20 20:25:02 +00:00
|
|
|
private:
|
|
|
|
cmake(const cmake&); // Not implemented.
|
|
|
|
void operator=(const cmake&); // Not implemented.
|
2006-03-15 16:02:08 +00:00
|
|
|
ProgressCallbackType ProgressCallback;
|
|
|
|
void* ProgressCallbackClientData;
|
|
|
|
bool Verbose;
|
|
|
|
bool InTryCompile;
|
|
|
|
bool ScriptMode;
|
2006-10-06 15:11:59 +00:00
|
|
|
bool DebugOutput;
|
2008-07-31 14:33:25 +00:00
|
|
|
bool Trace;
|
2010-08-25 16:35:40 +00:00
|
|
|
bool WarnUninitialized;
|
2010-08-25 16:36:21 +00:00
|
|
|
bool WarnUnused;
|
2010-08-24 20:49:49 +00:00
|
|
|
bool DefaultToUsed;
|
2008-02-12 14:49:42 +00:00
|
|
|
std::string CMakeEditCommand;
|
2006-03-15 16:02:08 +00:00
|
|
|
std::string CMakeCommand;
|
|
|
|
std::string CXXEnvironment;
|
|
|
|
std::string CCEnvironment;
|
|
|
|
std::string CheckBuildSystemArgument;
|
2007-11-10 13:15:13 +00:00
|
|
|
std::string CheckStampFile;
|
2008-03-11 21:25:49 +00:00
|
|
|
std::string CheckStampList;
|
2007-11-19 18:45:16 +00:00
|
|
|
std::string VSSolutionFile;
|
2006-03-15 16:02:08 +00:00
|
|
|
std::string CTestCommand;
|
|
|
|
std::string CPackCommand;
|
|
|
|
bool ClearBuildSystem;
|
|
|
|
bool DebugTryCompile;
|
|
|
|
cmFileTimeComparison* FileComparison;
|
|
|
|
std::string GraphVizFile;
|
2008-09-04 21:34:25 +00:00
|
|
|
std::vector<std::string> DebugConfigs;
|
2004-10-04 16:31:09 +00:00
|
|
|
|
|
|
|
void UpdateConversionPathTable();
|
2001-05-18 19:25:08 +00:00
|
|
|
};
|
|
|
|
|
2003-04-03 03:48:12 +00:00
|
|
|
#define CMAKE_STANDARD_OPTIONS_TABLE \
|
2005-09-21 17:31:43 +00:00
|
|
|
{"-C <initial-cache>", "Pre-load a script to populate the cache.", \
|
2003-04-03 03:48:12 +00:00
|
|
|
"When cmake is first run in an empty build tree, it creates a " \
|
|
|
|
"CMakeCache.txt file and populates it with customizable settings " \
|
|
|
|
"for the project. This option may be used to specify a file from " \
|
|
|
|
"which to load cache entries before the first pass through " \
|
|
|
|
"the project's cmake listfiles. The loaded entries take priority " \
|
2005-09-21 17:31:43 +00:00
|
|
|
"over the project's default values. The given file should be a CMake " \
|
|
|
|
"script containing SET commands that use the CACHE option, " \
|
|
|
|
"not a cache-format file."}, \
|
2005-07-19 21:16:23 +00:00
|
|
|
{"-D <var>:<type>=<value>", "Create a cmake cache entry.", \
|
2003-04-03 03:48:12 +00:00
|
|
|
"When cmake is first run in an empty build tree, it creates a " \
|
|
|
|
"CMakeCache.txt file and populates it with customizable settings " \
|
|
|
|
"for the project. This option may be used to specify a setting " \
|
|
|
|
"that takes priority over the project's default value. The option " \
|
|
|
|
"may be repeated for as many cache entries as desired."}, \
|
2007-06-04 17:48:11 +00:00
|
|
|
{"-U <globbing_expr>", "Remove matching entries from CMake cache.", \
|
2007-06-01 18:16:46 +00:00
|
|
|
"This option may be used to remove one or more variables from the " \
|
2007-06-04 17:48:11 +00:00
|
|
|
"CMakeCache.txt file, globbing expressions using * and ? are supported. "\
|
|
|
|
"The option may be repeated for as many cache entries as desired.\n" \
|
|
|
|
"Use with care, you can make your CMakeCache.txt non-working."}, \
|
2005-07-19 21:16:23 +00:00
|
|
|
{"-G <generator-name>", "Specify a makefile generator.", \
|
2003-04-03 03:48:12 +00:00
|
|
|
"CMake may support multiple native build systems on certain platforms. " \
|
|
|
|
"A makefile generator is responsible for generating a particular build " \
|
2003-07-11 03:22:09 +00:00
|
|
|
"system. Possible generator names are specified in the Generators " \
|
2008-03-11 20:02:10 +00:00
|
|
|
"section."},\
|
|
|
|
{"-Wno-dev", "Suppress developer warnings.",\
|
|
|
|
"Suppress warnings that are meant for the author"\
|
|
|
|
" of the CMakeLists.txt files."},\
|
|
|
|
{"-Wdev", "Enable developer warnings.",\
|
|
|
|
"Enable warnings that are meant for the author"\
|
|
|
|
" of the CMakeLists.txt files."}
|
|
|
|
|
2003-07-11 03:14:49 +00:00
|
|
|
|
|
|
|
#define CMAKE_STANDARD_INTRODUCTION \
|
2007-10-09 18:35:25 +00:00
|
|
|
{0, \
|
2003-07-11 03:14:49 +00:00
|
|
|
"CMake is a cross-platform build system generator. Projects " \
|
|
|
|
"specify their build process with platform-independent CMake listfiles " \
|
2006-05-12 18:36:39 +00:00
|
|
|
"included in each directory of a source tree with the name " \
|
|
|
|
"CMakeLists.txt. " \
|
2003-07-11 03:14:49 +00:00
|
|
|
"Users build a project by using CMake to generate a build system " \
|
2007-10-09 18:35:25 +00:00
|
|
|
"for a native tool on their platform.", 0}
|
2003-12-23 20:01:10 +00:00
|
|
|
#endif
|