2000-08-29 23:26:29 +04:00
|
|
|
/*=========================================================================
|
|
|
|
|
2002-10-24 02:03:27 +04:00
|
|
|
Program: CMake - Cross-Platform Makefile Generator
|
2000-08-29 23:26:29 +04:00
|
|
|
Module: $RCSfile$
|
|
|
|
Language: C++
|
|
|
|
Date: $Date$
|
|
|
|
Version: $Revision$
|
|
|
|
|
2002-10-24 02:03:27 +04:00
|
|
|
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
|
|
|
|
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
|
2000-08-29 23:26:29 +04:00
|
|
|
|
2002-01-21 23:30:43 +03:00
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even
|
|
|
|
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
|
|
PURPOSE. See the above copyright notices 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
|
|
|
|
2001-01-05 19:41:20 +03:00
|
|
|
#include "cmStandardIncludes.h"
|
2001-05-16 17:19:46 +04:00
|
|
|
#include "cmData.h"
|
2001-01-05 19:41:20 +03:00
|
|
|
#include "cmSystemTools.h"
|
2001-03-20 21:20:59 +03:00
|
|
|
#include "cmSourceGroup.h"
|
2001-04-11 22:59:02 +04:00
|
|
|
#include "cmTarget.h"
|
2002-12-12 02:13:33 +03:00
|
|
|
#include "cmListFileCache.h"
|
2001-08-08 19:54:46 +04:00
|
|
|
#include "cmCacheManager.h"
|
|
|
|
|
2001-04-20 01:39:03 +04:00
|
|
|
class cmFunctionBlocker;
|
2001-01-18 19:20:24 +03:00
|
|
|
class cmCommand;
|
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;
|
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
|
|
|
|
{
|
|
|
|
public:
|
2001-05-24 19:47:21 +04:00
|
|
|
/**
|
2001-06-07 22:52:29 +04:00
|
|
|
* Return major and minor version numbers for cmake.
|
2001-05-24 19:47:21 +04:00
|
|
|
*/
|
2001-12-08 00:01:32 +03:00
|
|
|
static unsigned int GetMajorVersion() { return 1;}
|
2003-01-06 17:36:27 +03:00
|
|
|
static unsigned int GetMinorVersion() { return 6;}
|
|
|
|
static const char *GetReleaseVersion() { return "beta 1";}
|
2002-01-03 00:44:44 +03:00
|
|
|
|
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();
|
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();
|
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.
|
|
|
|
*/
|
2001-04-30 18:52:58 +04:00
|
|
|
bool ReadListFile(const char* listfile, const char* external= 0);
|
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)
|
2002-07-10 19:38:38 +04:00
|
|
|
{ m_FunctionBlockers.push_back(fb);}
|
2001-04-20 01:39:03 +04:00
|
|
|
void RemoveFunctionBlocker(cmFunctionBlocker *fb)
|
2002-07-10 19:38:38 +04:00
|
|
|
{ m_FunctionBlockers.remove(fb);}
|
2002-12-12 02:13:33 +03:00
|
|
|
void RemoveFunctionBlocker(const cmListFileFunction& lff);
|
2001-04-20 01:39:03 +04:00
|
|
|
|
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,
|
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()
|
|
|
|
{ return m_LocalGenerator;}
|
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.
|
|
|
|
*/
|
2001-04-20 01:39:03 +04:00
|
|
|
void Print() const;
|
2001-01-05 19:41:20 +03:00
|
|
|
|
2001-01-11 22:47:38 +03:00
|
|
|
/**
|
2001-01-18 19:20:24 +03:00
|
|
|
* Add a custom command to the build.
|
2001-01-11 22:47:38 +03:00
|
|
|
*/
|
2001-01-18 19:20:24 +03:00
|
|
|
void AddCustomCommand(const char* source,
|
2001-03-20 21:20:59 +03:00
|
|
|
const char* command,
|
2001-09-10 23:11:15 +04:00
|
|
|
const std::vector<std::string>& commandArgs,
|
2001-03-20 21:20:59 +03:00
|
|
|
const std::vector<std::string>& depends,
|
2001-04-11 22:59:02 +04:00
|
|
|
const std::vector<std::string>& outputs,
|
2002-12-11 00:47:37 +03:00
|
|
|
const char *target,
|
|
|
|
const char *comment = 0);
|
2001-03-20 21:20:59 +03:00
|
|
|
|
|
|
|
void AddCustomCommand(const char* source,
|
|
|
|
const char* command,
|
2001-09-10 23:11:15 +04:00
|
|
|
const std::vector<std::string>& commandArgs,
|
2001-03-20 21:20:59 +03:00
|
|
|
const std::vector<std::string>& depends,
|
2001-04-11 22:59:02 +04:00
|
|
|
const char* output,
|
|
|
|
const char* target);
|
2001-03-20 21:20:59 +03:00
|
|
|
|
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);
|
2001-01-11 22:47:38 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Add an executable to the build.
|
|
|
|
*/
|
2001-05-11 18:53:17 +04:00
|
|
|
void AddExecutable(const char *exename,
|
|
|
|
const std::vector<std::string> &srcs);
|
|
|
|
void AddExecutable(const char *exename,
|
|
|
|
const std::vector<std::string> &srcs, bool win32);
|
2001-01-11 22:47:38 +03:00
|
|
|
|
2001-05-02 00:55:32 +04:00
|
|
|
/**
|
|
|
|
* Add a utility to the build. A utiltity target is
|
|
|
|
* a command that is run every time a target is built.
|
|
|
|
*/
|
|
|
|
void AddUtilityCommand(const char* utilityName,
|
2001-05-04 23:50:26 +04:00
|
|
|
const char* command,
|
2001-09-05 00:07:54 +04:00
|
|
|
const char* arguments,
|
2001-05-04 23:50:26 +04:00
|
|
|
bool all);
|
|
|
|
void AddUtilityCommand(const char* utilityName,
|
|
|
|
const char* command,
|
2001-09-05 00:07:54 +04:00
|
|
|
const char* arguments,
|
2001-05-04 23:50:26 +04:00
|
|
|
bool all,
|
|
|
|
const std::vector<std::string> &depends,
|
|
|
|
const std::vector<std::string> &outputs);
|
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
|
|
|
|
|
|
|
/**
|
|
|
|
* Add a subdirectory to the build.
|
|
|
|
*/
|
2001-01-05 19:41:20 +03:00
|
|
|
void AddSubDirectory(const char*);
|
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
|
|
|
|
2002-12-02 23:59:59 +03:00
|
|
|
/**
|
|
|
|
* Find a library (as in cmSystemTools) but add in compiler specific paths
|
|
|
|
*/
|
|
|
|
std::string FindLibrary(const char* name,
|
|
|
|
const std::vector<std::string>& path);
|
|
|
|
|
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,
|
|
|
|
cmCacheManager::CacheEntryType type);
|
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);
|
2001-08-08 19:54:46 +04:00
|
|
|
///! Add a definition to this makefile and the global cmake cache.
|
|
|
|
void AddCacheDefinition(const char* name, bool, const char* doc);
|
2001-04-24 20:40:37 +04:00
|
|
|
|
2002-09-18 18:39:41 +04:00
|
|
|
/**
|
|
|
|
* Remove a variable definition from the build. This is not valid
|
|
|
|
* for cache entries, and will only affect the current makefile.
|
|
|
|
*/
|
|
|
|
void RemoveDefinition(const char* name);
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
const char* GetProjectName()
|
|
|
|
{
|
|
|
|
return m_ProjectName.c_str();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the name of the library.
|
|
|
|
*/
|
2001-08-29 02:02:59 +04:00
|
|
|
void AddLibrary(const char *libname, int shared,
|
2001-07-02 23:38:02 +04:00
|
|
|
const std::vector<std::string> &srcs);
|
2001-01-11 22:47:38 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Add a class/source file to the build.
|
|
|
|
*/
|
2002-06-27 23:57:09 +04:00
|
|
|
//void AddSource(cmSourceFile& ,const char *srcListName);
|
2001-01-11 22:47:38 +03:00
|
|
|
|
2001-06-22 17:47:02 +04:00
|
|
|
/**
|
|
|
|
* Remove a class/source file from the build.
|
|
|
|
*/
|
2002-06-27 23:57:09 +04:00
|
|
|
//void RemoveSource(cmSourceFile& ,const char *srcListName);
|
2001-06-22 17:47:02 +04:00
|
|
|
|
2001-03-20 21:20:59 +03:00
|
|
|
/**
|
|
|
|
* Add a source group for consideration when adding a new source.
|
|
|
|
*/
|
2002-10-05 02:16:13 +04:00
|
|
|
void AddSourceGroup(const char* name, const char* regex=0);
|
2001-03-20 21:20:59 +03:00
|
|
|
|
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()
|
|
|
|
{
|
|
|
|
m_cmCurrentDirectory = m_cmStartDirectory;
|
|
|
|
m_CurrentOutputDirectory = m_StartOutputDirectory;
|
2002-12-11 00:47:37 +03:00
|
|
|
this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR", m_cmCurrentDirectory.c_str());
|
|
|
|
this->AddDefinition("CMAKE_CURRENT_BINARY_DIR", m_CurrentOutputDirectory.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
|
|
|
{
|
2001-01-11 22:47:38 +03:00
|
|
|
return m_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
|
|
|
{
|
2001-02-15 21:30:13 +03:00
|
|
|
return m_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
|
|
|
{
|
2001-02-15 21:30:13 +03:00
|
|
|
m_cmStartDirectory = dir;
|
|
|
|
cmSystemTools::ConvertToUnixSlashes(m_cmStartDirectory);
|
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
|
|
|
{
|
2001-02-15 21:30:13 +03:00
|
|
|
return m_cmStartDirectory.c_str();
|
2000-08-29 23:26:29 +04:00
|
|
|
}
|
2001-02-15 21:30:13 +03:00
|
|
|
void SetStartOutputDirectory(const char* lib)
|
|
|
|
{
|
|
|
|
m_StartOutputDirectory = lib;
|
|
|
|
cmSystemTools::ConvertToUnixSlashes(m_StartOutputDirectory);
|
2001-08-10 23:54:19 +04:00
|
|
|
cmSystemTools::MakeDirectory(m_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
|
|
|
{
|
2001-02-15 21:30:13 +03:00
|
|
|
return m_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-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 current directory (or output directory) in the project. The
|
|
|
|
* current directory is the directory of the CMakeLists.txt file that is
|
|
|
|
* currently being processed. 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 SetCurrentDirectory(const char* dir)
|
2000-08-29 23:26:29 +04:00
|
|
|
{
|
2001-02-15 21:30:13 +03:00
|
|
|
m_cmCurrentDirectory = dir;
|
|
|
|
cmSystemTools::ConvertToUnixSlashes(m_cmCurrentDirectory);
|
2002-12-11 00:47:37 +03:00
|
|
|
this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR", m_cmCurrentDirectory.c_str());
|
2000-08-29 23:26:29 +04:00
|
|
|
}
|
2001-04-25 00:49:12 +04:00
|
|
|
const char* GetCurrentDirectory() const
|
2001-02-15 21:30:13 +03:00
|
|
|
{
|
|
|
|
return m_cmCurrentDirectory.c_str();
|
|
|
|
}
|
|
|
|
void SetCurrentOutputDirectory(const char* lib)
|
|
|
|
{
|
|
|
|
m_CurrentOutputDirectory = lib;
|
|
|
|
cmSystemTools::ConvertToUnixSlashes(m_CurrentOutputDirectory);
|
2002-12-11 00:47:37 +03:00
|
|
|
this->AddDefinition("CMAKE_CURRENT_BINARY_DIR", m_CurrentOutputDirectory.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
|
|
|
{
|
|
|
|
return m_CurrentOutputDirectory.c_str();
|
|
|
|
}
|
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
|
|
|
|
{
|
|
|
|
return m_cmCurrentListFile.c_str();
|
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
m_IncludeFileRegularExpression = regex;
|
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
m_ComplainFileRegularExpression = regex;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
*/
|
2001-04-16 18:01:13 +04:00
|
|
|
cmTargets &GetTargets() { return m_Targets; }
|
2001-06-12 00:47:15 +04:00
|
|
|
const cmTargets &GetTargets() const { return m_Targets; }
|
2001-01-11 22:47:38 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get a list of the build subdirectories.
|
|
|
|
*/
|
2000-09-12 13:30:35 +04:00
|
|
|
const std::vector<std::string>& GetSubDirectories()
|
|
|
|
{
|
2001-01-11 22:47:38 +03:00
|
|
|
return m_SubDirectories;
|
2000-09-12 13:30:35 +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
|
|
|
{
|
2001-01-11 22:47:38 +03:00
|
|
|
return m_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
|
|
|
{
|
|
|
|
return m_IncludeDirectories;
|
|
|
|
}
|
2001-01-11 22:47:38 +03:00
|
|
|
|
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.
|
|
|
|
*/
|
2002-06-27 23:57:09 +04:00
|
|
|
cmSourceFile* GetSource(const char* sourceName) const;
|
2002-03-29 18:06:30 +03:00
|
|
|
///! Add a new cmSourceFile to the list of sources for this makefile.
|
|
|
|
cmSourceFile* AddSource(cmSourceFile const&);
|
2001-04-11 22:59:02 +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()
|
2001-01-11 22:47:38 +03:00
|
|
|
{return m_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
|
|
|
|
{return m_SourceFileExtensions;}
|
|
|
|
const std::vector<std::string>& GetHeaderExtensions() const
|
|
|
|
{return m_HeaderFileExtensions;}
|
|
|
|
//@}
|
|
|
|
|
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;
|
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;
|
2001-01-11 22:47:38 +03:00
|
|
|
|
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()
|
|
|
|
{return m_DefineFlags.c_str();}
|
2001-02-27 01:58:54 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the vector of used command instances.
|
|
|
|
*/
|
|
|
|
const std::vector<cmCommand*>& GetUsedCommands() const
|
|
|
|
{return m_UsedCommands;}
|
|
|
|
|
2001-03-20 21:20:59 +03:00
|
|
|
/**
|
|
|
|
* Get the vector source groups.
|
|
|
|
*/
|
|
|
|
const std::vector<cmSourceGroup>& GetSourceGroups() const
|
|
|
|
{ return m_SourceGroups; }
|
2001-04-30 18:52:58 +04:00
|
|
|
|
2002-10-05 02:16:13 +04:00
|
|
|
/**
|
|
|
|
* Get the source group
|
|
|
|
*/
|
|
|
|
cmSourceGroup* GetSourceGroup(const char* name);
|
|
|
|
|
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
|
|
|
|
{ return m_ListFiles; }
|
2001-03-20 21:20:59 +03:00
|
|
|
|
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)
|
|
|
|
{ m_ListFiles.push_back(file);}
|
|
|
|
|
2001-02-13 03:49:52 +03:00
|
|
|
/**
|
|
|
|
* Expand all defined varibles in the string.
|
|
|
|
* Defined varibles come from the m_Definitions map.
|
|
|
|
* They are expanded with ${var} where var is the
|
2001-02-14 00:48:00 +03:00
|
|
|
* entry in the m_Definitions map. Also @var@ is
|
|
|
|
* expanded to match autoconf style expansions.
|
2001-02-13 03:49:52 +03:00
|
|
|
*/
|
2001-09-02 00:12:52 +04:00
|
|
|
const char *ExpandVariablesInString(std::string& source) const;
|
2001-10-30 22:05:07 +03:00
|
|
|
const char *ExpandVariablesInString(std::string& source, bool escapeQuotes,
|
|
|
|
bool atOnly = false) const;
|
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.
|
|
|
|
*/
|
2001-10-30 22:05:07 +03: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();
|
2001-07-27 21:06:05 +04:00
|
|
|
|
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);
|
2001-05-16 17:19:46 +04:00
|
|
|
void RegisterData(cmData*);
|
|
|
|
void RegisterData(const char*, cmData*);
|
|
|
|
cmData* LookupData(const char*) const;
|
|
|
|
|
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
|
|
|
*/
|
2002-12-12 19:36:28 +03:00
|
|
|
bool ExecuteCommand(const cmListFileFunction& lff);
|
2001-07-26 00:53:13 +04:00
|
|
|
|
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* );
|
|
|
|
|
2002-04-03 00:43:23 +04:00
|
|
|
///! Enable support for the named language, if null then all languages are enabled.
|
|
|
|
void EnableLanguage(const char* );
|
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;
|
2002-08-28 22:51:10 +04:00
|
|
|
|
2002-09-20 23:01:00 +04:00
|
|
|
//! Determine wether this is a local or global build.
|
|
|
|
bool GetLocal() const;
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
void ExpandArguments(std::vector<cmListFileArgument> const& inArgs,
|
|
|
|
std::vector<std::string>& outArgs);
|
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);
|
|
|
|
|
2000-08-29 23:26:29 +04:00
|
|
|
std::string m_Prefix;
|
2001-01-05 19:41:20 +03:00
|
|
|
std::vector<std::string> m_AuxSourceDirectories; //
|
2001-02-15 21:30:13 +03:00
|
|
|
|
|
|
|
std::string m_cmCurrentDirectory;
|
|
|
|
std::string m_CurrentOutputDirectory;
|
|
|
|
std::string m_cmStartDirectory;
|
|
|
|
std::string m_StartOutputDirectory;
|
|
|
|
std::string m_cmHomeDirectory;
|
|
|
|
std::string m_HomeOutputDirectory;
|
2001-04-30 18:52:58 +04:00
|
|
|
std::string m_cmCurrentListFile;
|
2001-02-15 21:30:13 +03:00
|
|
|
|
2002-10-05 02:16:13 +04:00
|
|
|
std::string m_ProjectName; // project name
|
2001-04-11 22:59:02 +04:00
|
|
|
|
|
|
|
// libraries, classes, and executables
|
|
|
|
cmTargets m_Targets;
|
2002-03-29 18:06:30 +03:00
|
|
|
std::vector<cmSourceFile*> m_SourceFiles;
|
2001-04-11 22:59:02 +04:00
|
|
|
|
2000-08-29 23:26:29 +04:00
|
|
|
std::vector<std::string> m_SubDirectories; // list of sub directories
|
2001-08-22 19:58:17 +04:00
|
|
|
struct StringSet : public std::set<cmStdString>
|
2001-08-22 19:26:54 +04:00
|
|
|
{
|
|
|
|
};
|
2001-08-22 19:58:17 +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).
|
|
|
|
std::vector<std::string> m_IncludeDirectories;
|
|
|
|
std::vector<std::string> m_LinkDirectories;
|
|
|
|
|
2001-04-30 18:52:58 +04:00
|
|
|
std::vector<std::string> m_ListFiles; // list of command files loaded
|
2001-06-06 04:34:01 +04:00
|
|
|
|
|
|
|
|
2001-04-30 18:44:00 +04:00
|
|
|
cmTarget::LinkLibraries m_LinkLibraries;
|
2001-04-30 18:52:58 +04:00
|
|
|
|
2001-03-16 02:09:16 +03:00
|
|
|
std::string m_IncludeFileRegularExpression;
|
2001-06-21 23:02:52 +04:00
|
|
|
std::string m_ComplainFileRegularExpression;
|
2001-07-17 02:40:42 +04:00
|
|
|
std::vector<std::string> m_SourceFileExtensions;
|
|
|
|
std::vector<std::string> m_HeaderFileExtensions;
|
2001-01-05 19:41:20 +03:00
|
|
|
std::string m_DefineFlags;
|
2001-03-20 21:20:59 +03:00
|
|
|
std::vector<cmSourceGroup> m_SourceGroups;
|
2001-08-22 19:58:17 +04:00
|
|
|
typedef std::map<cmStdString, cmStdString> DefinitionMap;
|
2001-01-05 19:41:20 +03:00
|
|
|
DefinitionMap m_Definitions;
|
2001-01-18 19:20:24 +03:00
|
|
|
std::vector<cmCommand*> m_UsedCommands;
|
2002-09-06 21:06:23 +04:00
|
|
|
cmLocalGenerator* m_LocalGenerator;
|
2002-12-12 02:13:33 +03:00
|
|
|
bool IsFunctionBlocked(const cmListFileFunction& lff);
|
2001-04-11 22:59:02 +04:00
|
|
|
|
2001-01-11 22:47:38 +03:00
|
|
|
private:
|
2001-02-15 21:30:13 +03:00
|
|
|
/**
|
|
|
|
* Get the name of the parent directories CMakeLists file
|
|
|
|
* given a current CMakeLists file name
|
2001-01-11 22:47:38 +03:00
|
|
|
*/
|
2001-02-15 21:30:13 +03:00
|
|
|
std::string GetParentListFileName(const char *listFileName);
|
2001-01-11 22:47:38 +03:00
|
|
|
|
2001-04-25 00:49:12 +04:00
|
|
|
void ReadSources(std::ifstream& fin, bool t);
|
2002-10-05 02:16:13 +04:00
|
|
|
friend class cmMakeDepend; // make depend needs direct access
|
|
|
|
// to the m_Sources array
|
2001-04-20 01:39:03 +04:00
|
|
|
void PrintStringVector(const char* s, const std::vector<std::string>& v) const;
|
2001-03-08 18:30:18 +03:00
|
|
|
void AddDefaultDefinitions();
|
2002-07-10 19:38:38 +04:00
|
|
|
std::list<cmFunctionBlocker *> m_FunctionBlockers;
|
2001-05-16 17:19:46 +04:00
|
|
|
|
2001-08-22 19:58:17 +04:00
|
|
|
typedef std::map<cmStdString, cmData*> DataMap;
|
2001-05-16 17:19:46 +04:00
|
|
|
DataMap m_DataMap;
|
2001-07-26 00:53:13 +04:00
|
|
|
bool m_Inheriting;
|
2000-08-29 23:26:29 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
#endif
|