CMake/Source/cmMakefile.h

456 lines
11 KiB
C
Raw Normal View History

/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile$
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) 2000 National Library of Medicine
All rights reserved.
See COPYRIGHT.txt for copyright details.
=========================================================================*/
#ifndef cmMakefile_h
#define cmMakefile_h
2001-01-11 22:47:38 +03:00
#include "cmStandardIncludes.h"
#include "cmClassFile.h"
#include "cmSystemTools.h"
2001-01-11 22:47:38 +03:00
2001-01-18 19:20:24 +03:00
class cmCommand;
class cmMakefileGenerator;
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-01-11 22:47:38 +03:00
/**
* Construct an empty makefile.
*/
cmMakefile();
2001-01-11 22:47:38 +03:00
/**
* Destructor.
*/
~cmMakefile();
2001-01-11 22:47:38 +03:00
/**
* Read and parse a CMakeLists.txt file.
*/
2001-02-15 21:30:13 +03:00
bool ReadListFile(const char* listfile);
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
/**
* Specify the makefile generator. This is platform/compiler
* dependent, although the interface is through a generic
* superclass.
*/
void SetMakefileGenerator(cmMakefileGenerator*);
2001-01-11 22:47:38 +03:00
/**
* Produce the output makefile.
*/
void GenerateMakefile();
2001-01-11 22:47:38 +03:00
/**
* Print the object state to std::cout.
*/
void Print();
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* result,
const char* command,
std::vector<std::string>& depends);
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(cmClassFile&);
2001-01-11 22:47:38 +03:00
/**
* Add a utility on which this project depends.
*/
void AddUtility(const char*);
/**
* Add a directory in which a utility may be built.
*/
void AddUtilityDirectory(const char*);
2001-01-11 22:47:38 +03:00
/**
* Add a link library to the build.
*/
void AddLinkLibrary(const char*);
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*);
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);
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 SetLibraryName(const char*);
2001-01-11 22:47:38 +03:00
/**
* Add a class/source file to the build.
*/
void AddClass(cmClassFile& );
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-01-11 22:47:38 +03:00
m_cmHomeDirectory = dir;
cmSystemTools::ConvertToUnixSlashes(m_cmHomeDirectory);
}
const char* GetHomeDirectory()
{
2001-01-11 22:47:38 +03:00
return m_cmHomeDirectory.c_str();
}
2001-02-15 21:30:13 +03:00
void SetHomeOutputDirectory(const char* lib)
{
2001-02-15 21:30:13 +03:00
m_HomeOutputDirectory = lib;
cmSystemTools::ConvertToUnixSlashes(m_HomeOutputDirectory);
}
2001-02-15 21:30:13 +03:00
const char* GetHomeOutputDirectory()
{
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-02-15 21:30:13 +03:00
const char* GetStartDirectory()
{
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);
}
const char* GetStartOutputDirectory()
{
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-02-15 21:30:13 +03:00
const char* GetCurrentDirectory()
{
return m_cmCurrentDirectory.c_str();
}
void SetCurrentOutputDirectory(const char* lib)
{
m_CurrentOutputDirectory = lib;
cmSystemTools::ConvertToUnixSlashes(m_CurrentOutputDirectory);
}
const char* GetCurrentOutputDirectory()
{
return m_CurrentOutputDirectory.c_str();
}
//@}
2001-01-11 22:47:38 +03:00
/**
2001-02-15 21:30:13 +03:00
* Specify the name of the library that is built by this makefile.
2001-01-11 22:47:38 +03:00
*/
2001-02-15 21:30:13 +03:00
const char* GetLibraryName()
{
2001-02-15 21:30:13 +03:00
return m_LibraryName.c_str();
}
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
/**
* Return a boolean flag indicating whether the build generates
* any executables.
*/
2001-02-15 21:30:13 +03:00
bool HasExecutables();
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;
}
2001-01-11 22:47:38 +03:00
/**
* Get a list of link directories in the build.
*/
std::vector<std::string>& GetLinkDirectories()
{
2001-01-11 22:47:38 +03:00
return m_LinkDirectories;
}
/**
* Get a list of utilities on which the project depends.
*/
std::vector<std::string>& GetUtilities()
{
return m_Utilities;
}
/**
* Get a list of directories that may contain the Utilities.
*/
std::vector<std::string>& GetUtilityDirectories()
{
return m_UtilityDirectories;
}
2001-01-11 22:47:38 +03:00
/**
* Get a list of link libraries in the build.
*/
std::vector<std::string>& GetLinkLibraries()
{
2001-01-11 22:47:38 +03:00
return m_LinkLibraries;
}
2001-01-11 22:47:38 +03:00
/**
* Get a list of Win32 link libraries in the build.
*/
std::vector<std::string>& GetLinkLibrariesWin32()
{
2001-01-11 22:47:38 +03:00
return m_LinkLibrariesWin32;
}
2001-01-11 22:47:38 +03:00
/**
* Get a list of Unix link libraries in the build.
*/
std::vector<std::string>& GetLinkLibrariesUnix()
{
2001-01-11 22:47:38 +03:00
return m_LinkLibrariesUnix;
}
2001-01-11 22:47:38 +03:00
/**
* Return a list of source files in this makefile.
*/
std::vector<cmClassFile>& GetClasses()
{return m_Classes;}
/**
* Obtain a list of auxiliary source directories.
*/
std::vector<std::string>& GetAuxSourceDirectories()
2001-01-11 22:47:38 +03:00
{return m_AuxSourceDirectories;}
2001-01-11 22:47:38 +03:00
/**
* Do not use this.
*/
std::vector<std::string>& GetMakeVerbatim()
{return m_MakeVerbatim;}
2001-01-11 22:47:38 +03:00
/**
* Given a variable name, return its value (as a string).
*/
2001-01-11 22:47:38 +03:00
const char* GetDefinition(const char*);
/**
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;}
/**
* Dump documentation to a file. If 0 is returned, the
* operation failed.
*/
int DumpDocumentationToFile(const char *fileName);
/**
* 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.
*/
void ExpandVariablesInString(std::string& source);
/**
* Expand variables in the makefiles ivars such as link directories etc
*/
void ExpandVariables();
2001-02-27 01:17:34 +03:00
struct customCommand
{
std::string m_Source;
std::string m_Result;
std::string m_Command;
std::vector<std::string> m_Depends;
};
std::vector<customCommand>& GetCustomCommands() {
return m_CustomCommands; };
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.
*/
void FindSubDirectoryCMakeListsFiles(std::vector<cmMakefile*>& makefiles);
/** Generate the cache file only. This is done
* by calling FindSubDirectoryCMakeListsFiles which
* will cause all the rules to fire, and the cache to
* be filled.
*/
void GenerateCacheOnly();
2001-02-27 01:17:34 +03:00
protected:
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;
std::string m_LibraryName; // library name
std::string m_ProjectName; // project name
std::vector<cmClassFile> m_Classes; // list of classes in makefile
std::vector<std::string> m_SubDirectories; // list of sub directories
std::vector<std::string> m_MakeVerbatim; // lines copied from input file
std::vector<std::string> m_IncludeDirectories;
std::vector<std::string> m_LinkDirectories;
std::vector<std::string> m_Utilities;
std::vector<std::string> m_UtilityDirectories;
std::vector<std::string> m_LinkLibraries;
std::vector<std::string> m_LinkLibrariesWin32;
std::vector<std::string> m_LinkLibrariesUnix;
std::string m_DefineFlags;
2001-01-18 19:20:24 +03:00
std::vector<customCommand> m_CustomCommands;
typedef std::map<std::string, cmCommand*> RegisteredCommandsMap;
typedef std::map<std::string, std::string> DefinitionMap;
DefinitionMap m_Definitions;
2001-01-18 19:20:24 +03:00
RegisteredCommandsMap m_Commands;
std::vector<cmCommand*> m_UsedCommands;
cmMakefileGenerator* m_MakefileGenerator;
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
void ReadClasses(std::ifstream& fin, bool t);
friend class cmMakeDepend; // make depend needs direct access
// to the m_Classes array
void PrintStringVector(const char* s, std::vector<std::string>& v);
2001-01-18 19:20:24 +03:00
void AddDefaultCommands();
void AddDefaultDefinitions();
};
#endif