2002-08-31 00:00:35 +04:00
|
|
|
/*=========================================================================
|
|
|
|
|
2002-10-24 02:03:27 +04:00
|
|
|
Program: CMake - Cross-Platform Makefile Generator
|
2002-08-31 00:00:35 +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.
|
2002-08-31 00:00:35 +04: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 cmLocalGenerator_h
|
|
|
|
#define cmLocalGenerator_h
|
|
|
|
|
|
|
|
#include "cmStandardIncludes.h"
|
|
|
|
|
|
|
|
class cmMakefile;
|
|
|
|
class cmGlobalGenerator;
|
2004-01-26 03:25:26 +03:00
|
|
|
class cmTarget;
|
2004-10-21 22:34:02 +04:00
|
|
|
class cmSourceFile;
|
|
|
|
|
2002-08-31 00:00:35 +04:00
|
|
|
|
|
|
|
/** \class cmLocalGenerator
|
|
|
|
* \brief Create required build files for a directory.
|
|
|
|
*
|
|
|
|
* Subclasses of this abstract class generate makefiles, DSP, etc for various
|
|
|
|
* platforms. This class should never be constructued directly. A
|
|
|
|
* GlobalGenerator will create it and invoke the appropriate commands on it.
|
|
|
|
*/
|
|
|
|
class cmLocalGenerator
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
cmLocalGenerator();
|
2002-09-05 17:04:55 +04:00
|
|
|
virtual ~cmLocalGenerator();
|
2002-08-31 00:00:35 +04:00
|
|
|
|
|
|
|
/**
|
2005-03-18 18:41:41 +03:00
|
|
|
* Generate the makefile for this directory.
|
2002-08-31 00:00:35 +04:00
|
|
|
*/
|
2005-03-18 18:41:41 +03:00
|
|
|
virtual void Generate() {};
|
2002-08-31 00:00:35 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Process the CMakeLists files for this directory to fill in the
|
|
|
|
* m_Makefile ivar
|
|
|
|
*/
|
|
|
|
virtual void Configure();
|
|
|
|
|
2002-09-15 16:54:16 +04:00
|
|
|
/**
|
|
|
|
* Perform any final calculations prior to generation
|
|
|
|
*/
|
|
|
|
virtual void ConfigureFinalPass();
|
|
|
|
|
2004-01-26 03:25:26 +03:00
|
|
|
/**
|
|
|
|
* Generate the install rules files in this directory.
|
|
|
|
*/
|
|
|
|
virtual void GenerateInstallRules();
|
|
|
|
|
2005-04-24 23:59:51 +04:00
|
|
|
/**
|
|
|
|
* Generate the test files for tests.
|
|
|
|
*/
|
|
|
|
virtual void GenerateTestFiles();
|
|
|
|
|
|
|
|
|
2002-08-31 00:00:35 +04:00
|
|
|
///! Get the makefile for this generator
|
|
|
|
cmMakefile *GetMakefile() {
|
|
|
|
return this->m_Makefile; };
|
|
|
|
|
|
|
|
///! Get the GlobalGenerator this is associated with
|
|
|
|
cmGlobalGenerator *GetGlobalGenerator() {
|
|
|
|
return m_GlobalGenerator; };
|
|
|
|
|
|
|
|
///! Set the Global Generator, done on creation by the GlobalGenerator
|
2002-09-04 23:24:49 +04:00
|
|
|
void SetGlobalGenerator(cmGlobalGenerator *gg);
|
2004-01-26 03:25:26 +03:00
|
|
|
|
2005-05-13 17:54:30 +04:00
|
|
|
/**
|
|
|
|
* Convert something to something else. This is a centralized coversion
|
|
|
|
* routine used by the generators to handle relative paths and the like.
|
|
|
|
* The flags determine what is actually done.
|
|
|
|
*
|
|
|
|
* relative: treat the argument as a directory and convert it to make it
|
|
|
|
* relative or full or unchanged. If relative (HOME, START etc) then that
|
|
|
|
* specifies what it should be relative to.
|
|
|
|
*
|
|
|
|
* output: make the result suitable for output to a...
|
|
|
|
*
|
|
|
|
* optional: should any relative path operation be controlled by the rel
|
|
|
|
* path setting
|
|
|
|
*/
|
|
|
|
enum RelativeRoot { NONE, FULL, HOME, START, HOME_OUTPUT, START_OUTPUT };
|
|
|
|
enum OutputFormat { UNCHANGED, MAKEFILE, SHELL };
|
|
|
|
std::string Convert(const char* source,
|
|
|
|
RelativeRoot relative,
|
|
|
|
OutputFormat output = UNCHANGED,
|
|
|
|
bool optional = false);
|
|
|
|
|
2005-07-27 17:49:37 +04:00
|
|
|
///! Call this prior to using Convert
|
|
|
|
void SetupPathConversions();
|
|
|
|
|
2005-02-25 00:04:54 +03:00
|
|
|
/**
|
|
|
|
* Convert the given path to an output path that is optionally
|
|
|
|
* relative based on the cache option CMAKE_USE_RELATIVE_PATHS. The
|
|
|
|
* remote path must use forward slashes and not already be escaped
|
|
|
|
* or quoted.
|
|
|
|
*/
|
|
|
|
std::string ConvertToOptionallyRelativeOutputPath(const char* remote);
|
|
|
|
|
2004-03-10 00:28:44 +03:00
|
|
|
// flag to determine if this project should be included in a parent project
|
|
|
|
bool GetExcludeAll()
|
|
|
|
{
|
|
|
|
return m_ExcludeFromAll;
|
|
|
|
}
|
|
|
|
void SetExcludeAll(bool b)
|
|
|
|
{
|
|
|
|
m_ExcludeFromAll = b;
|
|
|
|
}
|
|
|
|
|
|
|
|
///! set/get the parent generator
|
|
|
|
cmLocalGenerator* GetParent(){return m_Parent;}
|
2005-03-18 18:41:41 +03:00
|
|
|
void SetParent(cmLocalGenerator* g) { m_Parent = g; g->AddChild(this); }
|
|
|
|
|
|
|
|
///! set/get the children
|
|
|
|
void AddChild(cmLocalGenerator* g) { this->Children.push_back(g); }
|
|
|
|
std::vector<cmLocalGenerator*>& GetChildren() { return this->Children; };
|
|
|
|
|
2004-06-28 22:40:17 +04:00
|
|
|
|
2005-02-02 21:19:57 +03:00
|
|
|
void AddLanguageFlags(std::string& flags, const char* lang);
|
|
|
|
void AddSharedFlags(std::string& flags, const char* lang, bool shared);
|
|
|
|
void AddConfigVariableFlags(std::string& flags, const char* var);
|
|
|
|
void AppendFlags(std::string& flags, const char* newFlags);
|
2005-02-04 01:42:55 +03:00
|
|
|
///! Get the include flags for the current makefile and language
|
|
|
|
const char* GetIncludeFlags(const char* lang);
|
2005-02-02 21:19:57 +03:00
|
|
|
|
2006-01-14 02:18:32 +03:00
|
|
|
/** Translate a dependency as given in CMake code to the name to
|
|
|
|
appear in a generated build file. If the given name is that of
|
|
|
|
a CMake target it will be transformed to the real output
|
|
|
|
location of that target for the given configuration. Otherwise
|
|
|
|
the original name will be returned. If the local argument is
|
|
|
|
given it is set to indicate whethr the name is of a utility
|
|
|
|
target available in the same makefile. */
|
|
|
|
std::string GetRealDependency(const char* name, const char* config,
|
|
|
|
bool* local=0);
|
|
|
|
|
2005-02-15 00:46:32 +03:00
|
|
|
///! for existing files convert to output path and short path if spaces
|
|
|
|
std::string ConvertToOutputForExisting(const char* p);
|
|
|
|
|
2005-05-12 18:49:56 +04:00
|
|
|
/** Called from command-line hook to check dependencies. */
|
2005-06-10 18:45:08 +04:00
|
|
|
virtual void CheckDependencies(cmMakefile* /* mf */,
|
|
|
|
bool /* verbose */,
|
|
|
|
bool /* clear */) {};
|
|
|
|
|
2005-05-12 18:49:56 +04:00
|
|
|
/** Called from command-line hook to scan dependencies. */
|
|
|
|
virtual bool ScanDependencies(std::vector<std::string> const& /* args */) {return true;};
|
|
|
|
|
2006-01-14 02:18:32 +03:00
|
|
|
/** Compute the list of link libraries and directories for the given
|
|
|
|
target and configuration. */
|
|
|
|
void ComputeLinkInformation(cmTarget& target, const char* config,
|
|
|
|
std::vector<cmStdString>& outLibs,
|
|
|
|
std::vector<cmStdString>& outDirs,
|
|
|
|
std::vector<cmStdString>* fullPathLibs=0);
|
|
|
|
|
2005-02-03 01:16:07 +03:00
|
|
|
protected:
|
2005-02-22 18:32:44 +03:00
|
|
|
/** Construct a script from the given list of command lines. */
|
|
|
|
std::string ConstructScript(const cmCustomCommandLines& commandLines,
|
|
|
|
const char* newline = "\n");
|
2005-02-03 01:16:07 +03:00
|
|
|
|
2004-10-21 22:34:02 +04:00
|
|
|
///! Fill out these strings for the given target. Libraries to link, flags, and linkflags.
|
|
|
|
void GetTargetFlags(std::string& linkLibs,
|
|
|
|
std::string& flags,
|
|
|
|
std::string& linkFlags,
|
|
|
|
cmTarget&target);
|
|
|
|
|
|
|
|
///! put all the libraries for a target on into the given stream
|
2005-06-22 17:06:46 +04:00
|
|
|
virtual void OutputLinkLibraries(std::ostream&, const char* name,cmTarget &);
|
2004-10-21 22:34:02 +04:00
|
|
|
|
2006-01-14 02:18:32 +03:00
|
|
|
/** Compute the string to use to refer to a target in an install
|
|
|
|
file. */
|
|
|
|
std::string GetInstallReference(cmTarget& target, const char* config,
|
|
|
|
std::vector<std::string> const& configs,
|
|
|
|
bool implib = false);
|
|
|
|
void PrepareInstallReference(std::ostream& fout, cmTarget& target,
|
|
|
|
std::vector<std::string> const& configs);
|
2004-10-26 18:15:49 +04:00
|
|
|
|
|
|
|
/** Get the include flags for the current makefile and language. */
|
|
|
|
void GetIncludeDirectories(std::vector<std::string>& dirs);
|
|
|
|
|
2004-10-21 22:34:02 +04:00
|
|
|
// Expand rule variables in CMake of the type found in language rules
|
|
|
|
void ExpandRuleVariables(std::string& string,
|
|
|
|
const char* language,
|
|
|
|
const char* objects=0,
|
|
|
|
const char* target=0,
|
|
|
|
const char* linkLibs=0,
|
|
|
|
const char* source=0,
|
|
|
|
const char* object =0,
|
|
|
|
const char* flags = 0,
|
|
|
|
const char* objectsquoted = 0,
|
|
|
|
const char* targetSOName = 0,
|
|
|
|
const char* linkFlags = 0);
|
2005-04-12 21:27:07 +04:00
|
|
|
// Expand rule variables in a single string
|
|
|
|
std::string ExpandRuleVariable(std::string const& variable,
|
|
|
|
const char* lang,
|
|
|
|
const char* objects,
|
|
|
|
const char* target,
|
|
|
|
const char* linkLibs,
|
|
|
|
const char* source,
|
|
|
|
const char* object,
|
|
|
|
const char* flags,
|
|
|
|
const char* objectsquoted,
|
|
|
|
const char* targetSOName,
|
|
|
|
const char* linkFlags);
|
|
|
|
|
2004-10-21 22:34:02 +04:00
|
|
|
///! Convert a target to a utility target for unsupported languages of a generator
|
|
|
|
void AddBuildTargetRule(const char* llang, cmTarget& target);
|
|
|
|
///! add a custom command to build a .o file that is part of a target
|
|
|
|
void AddCustomCommandToCreateObject(const char* ofname,
|
|
|
|
const char* lang,
|
|
|
|
cmSourceFile& source,
|
|
|
|
cmTarget& target);
|
|
|
|
// Create Custom Targets and commands for unsupported languages
|
|
|
|
// The set passed in should contain the languages supported by the
|
|
|
|
// generator directly. Any targets containing files that are not
|
|
|
|
// of the types listed will be compiled as custom commands and added
|
|
|
|
// to a custom target.
|
|
|
|
void CreateCustomTargetsAndCommands(std::set<cmStdString> const&);
|
2004-01-27 20:37:30 +03:00
|
|
|
virtual void AddInstallRule(std::ostream& fout, const char* dest, int type,
|
2004-06-28 22:40:17 +04:00
|
|
|
const char* files, bool optional = false, const char* properties = 0);
|
2005-04-24 23:59:51 +04:00
|
|
|
|
2002-08-31 00:00:35 +04:00
|
|
|
cmMakefile *m_Makefile;
|
|
|
|
cmGlobalGenerator *m_GlobalGenerator;
|
2003-12-22 23:16:46 +03:00
|
|
|
// members used for relative path function ConvertToMakefilePath
|
|
|
|
std::string m_RelativePathToSourceDir;
|
|
|
|
std::string m_RelativePathToBinaryDir;
|
2005-05-13 17:54:30 +04:00
|
|
|
std::vector<std::string> m_HomeDirectoryComponents;
|
|
|
|
std::vector<std::string> m_StartDirectoryComponents;
|
|
|
|
std::vector<std::string> m_HomeOutputDirectoryComponents;
|
|
|
|
std::vector<std::string> m_StartOutputDirectoryComponents;
|
2004-03-10 00:28:44 +03:00
|
|
|
bool m_ExcludeFromAll;
|
|
|
|
cmLocalGenerator* m_Parent;
|
2005-03-18 18:41:41 +03:00
|
|
|
std::vector<cmLocalGenerator*> Children;
|
2004-10-21 22:34:02 +04:00
|
|
|
std::map<cmStdString, cmStdString> m_LanguageToIncludeFlags;
|
|
|
|
bool m_WindowsShell;
|
2005-12-23 00:42:36 +03:00
|
|
|
bool m_ForceUnixPath;
|
2004-10-21 22:34:02 +04:00
|
|
|
bool m_UseRelativePaths;
|
|
|
|
bool m_IgnoreLibPrefix;
|
2005-03-18 18:41:41 +03:00
|
|
|
bool Configured;
|
2002-08-31 00:00:35 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif
|