CMake/Source/cmMakefile.h

583 lines
17 KiB
C
Raw Normal View History

/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile$
Language: C++
Date: $Date$
Version: $Revision$
2002-01-21 23:30:43 +03:00
Copyright (c) 2002 Insight Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
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.
=========================================================================*/
#ifndef cmMakefile_h
#define cmMakefile_h
2001-01-11 22:47:38 +03:00
#include "cmStandardIncludes.h"
#include "cmData.h"
2001-04-25 00:49:12 +04:00
#include "cmSourceFile.h"
#include "cmSystemTools.h"
#include "cmSourceGroup.h"
#include "cmTarget.h"
#include "cmCacheManager.h"
2001-04-20 01:39:03 +04:00
class cmFunctionBlocker;
2001-01-18 19:20:24 +03:00
class cmCommand;
class cmMakefileGenerator;
class cmMakeDepend;
2001-01-11 22:47:38 +03:00
/** \class cmMakefile
* \brief Process the input CMakeLists.txt file.
*
* Process and store into memory the input CMakeLists.txt file.
2001-01-18 19:20:24 +03:00
* Each CMakeLists.txt file is parsed and the commands found there
2001-01-11 22:47:38 +03:00
* are added into the build process.
*/
class cmMakefile
{
public:
2001-05-24 19:47:21 +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;}
2002-06-05 21:30:54 +04:00
static unsigned int GetMinorVersion() { return 5;}
2002-01-15 23:50:35 +03:00
static const char *GetReleaseVersion() { return "development";}
2002-01-03 00:44:44 +03: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.
*/
static unsigned int GetCacheMajorVersion();
static 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
/**
* Add a wrapper generator.
*/
2001-01-18 19:20:24 +03:00
void AddCommand(cmCommand* );
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)
{ m_FunctionBlockers.push_back(fb);}
2001-04-20 01:39:03 +04:00
void RemoveFunctionBlocker(cmFunctionBlocker *fb)
{ m_FunctionBlockers.remove(fb);}
2001-04-20 01:39:03 +04:00
void RemoveFunctionBlocker(const char *name, const std::vector<std::string> &args);
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.
*/
void SetMakefileGenerator(cmMakefileGenerator*);
///! Get the current makefile generator.
cmMakefileGenerator* GetMakefileGenerator()
{ return m_MakefileGenerator;}
2001-01-11 22:47:38 +03:00
/**
* Produce the output makefile.
*/
void GenerateMakefile();
/**
* 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-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,
const char* command,
2001-09-10 23:11:15 +04:00
const std::vector<std::string>& commandArgs,
const std::vector<std::string>& depends,
const std::vector<std::string>& outputs,
const char *target);
void AddCustomCommand(const char* source,
const char* command,
2001-09-10 23:11:15 +04:00
const std::vector<std::string>& commandArgs,
const std::vector<std::string>& depends,
const char* output,
const char* target);
2001-01-11 22:47:38 +03:00
/**
* Add a define flag to the build.
*/
void AddDefineFlag(const char* definition);
2001-01-11 22:47:38 +03:00
/**
* Add an executable to the build.
*/
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
/**
* 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,
const char* command,
const char* arguments,
bool all);
void AddUtilityCommand(const char* utilityName,
const char* command,
const char* arguments,
bool all,
const std::vector<std::string> &depends,
const std::vector<std::string> &outputs);
2001-01-11 22:47:38 +03:00
/**
* Add a link library to the build.
*/
void AddLinkLibrary(const char*);
void AddLinkLibrary(const char*, cmTarget::LinkLibraryType type);
void AddLinkLibraryForTarget(const char *tgt, const char*,
cmTarget::LinkLibraryType type);
void AddLinkDirectoryForTarget(const char *tgt, const char* d);
2001-01-11 22:47:38 +03:00
/**
* Add a link directory to the build.
*/
void AddLinkDirectory(const char*);
2001-01-11 22:47:38 +03:00
/**
* Add a subdirectory to the build.
*/
void AddSubDirectory(const char*);
2001-01-11 22:47:38 +03:00
/**
* Add an include directory to the build.
*/
void AddIncludeDirectory(const char*, bool before = false);
2001-01-11 22:47:38 +03:00
/**
* Add a variable definition to the build. This variable
* can be used in CMake to refer to lists, directories, etc.
*/
void AddDefinition(const char* name, const char* value);
///! Add a definition to this makefile and the global cmake cache.
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);
///! 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
2001-01-11 22:47:38 +03:00
/**
* Specify the name of the project for this build.
*/
void SetProjectName(const char*);
2001-01-11 22:47:38 +03:00
/**
* Get the name of the project for this build.
*/
const char* GetProjectName()
{
return m_ProjectName.c_str();
}
/**
* Set the name of the library.
*/
void AddLibrary(const char *libname, int shared,
const std::vector<std::string> &srcs);
2001-01-11 22:47:38 +03:00
/**
* Add a class/source file to the build.
*/
//void AddSource(cmSourceFile& ,const char *srcListName);
2001-01-11 22:47:38 +03:00
/**
* Remove a class/source file from the build.
*/
//void RemoveSource(cmSourceFile& ,const char *srcListName);
/**
* Add a source group for consideration when adding a new source.
*/
void AddSourceGroup(const char* name, const char* regex);
2001-01-11 22:47:38 +03:00
/**
* Add an auxiliary directory to the build.
*/
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;
}
//@{
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
*/
void SetHomeDirectory(const char* dir);
2001-04-25 00:49:12 +04:00
const char* GetHomeDirectory() const
{
2001-01-11 22:47:38 +03:00
return m_cmHomeDirectory.c_str();
}
void SetHomeOutputDirectory(const char* lib);
2001-04-25 00:49:12 +04:00
const char* GetHomeOutputDirectory() const
{
2001-02-15 21:30:13 +03:00
return m_HomeOutputDirectory.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 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)
{
2001-02-15 21:30:13 +03:00
m_cmStartDirectory = dir;
cmSystemTools::ConvertToUnixSlashes(m_cmStartDirectory);
}
2001-04-25 00:49:12 +04:00
const char* GetStartDirectory() const
{
2001-02-15 21:30:13 +03:00
return m_cmStartDirectory.c_str();
}
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
{
2001-02-15 21:30:13 +03:00
return m_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
//@{
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)
{
2001-02-15 21:30:13 +03:00
m_cmCurrentDirectory = dir;
cmSystemTools::ConvertToUnixSlashes(m_cmCurrentDirectory);
}
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);
}
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
//@}
/**
* 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;
}
/**
* 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
/**
* 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; }
const cmTargets &GetTargets() const { return m_Targets; }
2001-01-11 22:47:38 +03:00
/**
* Get a list of the build subdirectories.
*/
const std::vector<std::string>& GetSubDirectories()
{
2001-01-11 22:47:38 +03:00
return m_SubDirectories;
}
2001-01-11 22:47:38 +03:00
/**
* Get a list of include directories in the build.
*/
std::vector<std::string>& GetIncludeDirectories()
{
2001-01-11 22:47:38 +03:00
return m_IncludeDirectories;
}
const std::vector<std::string>& GetIncludeDirectories() const
{
return m_IncludeDirectories;
}
2001-01-11 22:47:38 +03: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
*/
void ExpandSourceListArguments(std::vector<std::string> const& argsIn,
std::vector<std::string>& argsOut,
2002-07-02 16:24:36 +04:00
unsigned int startArgumentIndex);
/** Get a cmSourceFile pointer for a given source name, if the name is
* not found, then a null pointer is returned.
*/
cmSourceFile* GetSource(const char* sourceName) const;
///! Add a new cmSourceFile to the list of sources for this makefile.
cmSourceFile* AddSource(cmSourceFile const&);
2001-01-11 22:47:38 +03:00
/**
* Obtain a list of auxiliary source directories.
*/
std::vector<std::string>& GetAuxSourceDirectories()
2001-01-11 22:47:38 +03:00
{return m_AuxSourceDirectories;}
//@{
/**
* 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).
* If the variable is not found in this makefile instance, the
* cache is then queried.
*/
2002-08-24 00:13:34 +04:00
const char* GetDefinition(const char*) const;
/** 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-11 22:47:38 +03:00
* Get a list of preprocessor define flags.
*/
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;}
/**
* Get the vector source groups.
*/
const std::vector<cmSourceGroup>& GetSourceGroups() const
{ return m_SourceGroups; }
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; }
///! When the file changes cmake will be re-run from the build system.
void AddCMakeDependFile(const char* file)
{ m_ListFiles.push_back(file);}
/**
* Dump documentation to a file. If 0 is returned, the
* operation failed.
*/
2002-08-24 00:13:34 +04:00
int DumpDocumentationToFile(std::ostream&);
/**
* Expand all defined varibles in the string.
* Defined varibles come from the m_Definitions map.
* They are expanded with ${var} where var is the
* entry in the m_Definitions map. Also @var@ is
* expanded to match autoconf style expansions.
*/
const char *ExpandVariablesInString(std::string& source) const;
const char *ExpandVariablesInString(std::string& source, bool escapeQuotes,
bool atOnly = false) const;
/**
* Remove any remaining variables in the string. Anything with ${var} or
* @var@ will be removed.
*/
void RemoveVariablesInString(std::string& source, bool atOnly = false) const;
/**
* Expand variables in the makefiles ivars such as link directories etc
*/
void ExpandVariables();
2001-02-23 03:24:43 +03:00
/** Recursivly read and create a cmMakefile object for
* all CMakeLists.txt files in the GetSubDirectories list.
* Once the file is found, it ReadListFile is called on
* the cmMakefile created for it. CreateObject is called on
* the prototype to create a cmMakefileGenerator for each cmMakefile that
* is created.
2001-02-23 03:24:43 +03:00
*/
void FindSubDirectoryCMakeListsFiles(std::vector<cmMakefile*>& makefiles);
/**
* find what source group this source is in
*/
cmSourceGroup& FindSourceGroup(const char* source,
std::vector<cmSourceGroup> &groups);
void RegisterData(cmData*);
void RegisterData(const char*, cmData*);
cmData* LookupData(const char*) const;
2001-07-26 00:53:13 +04:00
/**
* execute a single CMake command
*/
2002-08-21 21:16:07 +04:00
void ExecuteCommand(std::string const &name, std::vector<std::string> const& args);
2001-07-26 00:53:13 +04:00
/** Check if a command exists. */
bool CommandExists(const char* name) const;
2001-07-26 00:53:13 +04:00
///! Enable support for the named language, if null then all languages are enabled.
void EnableLanguage(const char* );
protected:
// add link libraries and directories to the target
void AddGlobalLinkInformation(const char* name, cmTarget& target);
std::string m_Prefix;
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
std::string m_ProjectName; // project name
// libraries, classes, and executables
cmTargets m_Targets;
std::vector<cmSourceFile*> m_SourceFiles;
std::vector<std::string> m_SubDirectories; // list of sub directories
struct StringSet : public std::set<cmStdString>
2001-08-22 19:26:54 +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
cmTarget::LinkLibraries m_LinkLibraries;
2001-04-30 18:52:58 +04:00
std::string m_IncludeFileRegularExpression;
std::string m_ComplainFileRegularExpression;
std::vector<std::string> m_SourceFileExtensions;
std::vector<std::string> m_HeaderFileExtensions;
std::string m_DefineFlags;
std::vector<cmSourceGroup> m_SourceGroups;
typedef std::map<cmStdString, cmCommand*> RegisteredCommandsMap;
typedef std::map<cmStdString, cmStdString> DefinitionMap;
DefinitionMap m_Definitions;
2001-01-18 19:20:24 +03:00
RegisteredCommandsMap m_Commands;
std::vector<cmCommand*> m_UsedCommands;
cmMakefileGenerator* m_MakefileGenerator;
bool IsFunctionBlocked(const char *name, std::vector<std::string> const& args);
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);
2001-01-11 22:47:38 +03:00
friend class cmMakeDepend; // make depend needs direct access
2001-04-25 00:49:12 +04:00
// 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-01-18 19:20:24 +03:00
void AddDefaultCommands();
void AddDefaultDefinitions();
std::list<cmFunctionBlocker *> m_FunctionBlockers;
typedef std::map<cmStdString, cmData*> DataMap;
DataMap m_DataMap;
2001-07-26 00:53:13 +04:00
bool m_Inheriting;
};
#endif