CMake/Source/cmLocalGenerator.h

282 lines
10 KiB
C
Raw Normal View History

2002-08-31 00:00:35 +04:00
/*=========================================================================
Program: CMake - Cross-Platform Makefile Generator
2002-08-31 00:00:35 +04:00
Module: $RCSfile$
Language: C++
Date: $Date$
Version: $Revision$
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;
class cmTarget;
class cmTargetManifest;
class cmSourceFile;
class cmCustomCommand;
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
/**
* Generate the makefile for this directory.
2002-08-31 00:00:35 +04:00
*/
virtual void Generate() {};
2002-08-31 00:00:35 +04:00
/**
* Process the CMakeLists files for this directory to fill in the
2006-03-15 19:02:08 +03:00
* Makefile ivar
2002-08-31 00:00:35 +04:00
*/
virtual void Configure();
2002-09-15 16:54:16 +04:00
/**
* Perform any final calculations prior to generation
*/
virtual void ConfigureFinalPass();
/**
* Generate the install rules files in this directory.
*/
virtual void GenerateInstallRules();
/**
* Generate the test files for tests.
*/
virtual void GenerateTestFiles();
/**
* Generate a manifest of target files that will be built.
*/
virtual void GenerateTargetManifest(cmTargetManifest&);
2002-08-31 00:00:35 +04:00
///! Get the makefile for this generator
cmMakefile *GetMakefile() {
2006-03-15 19:02:08 +03:00
return this->Makefile; };
2002-08-31 00:00:35 +04:00
///! Get the GlobalGenerator this is associated with
cmGlobalGenerator *GetGlobalGenerator() {
2006-03-15 19:02:08 +03:00
return this->GlobalGenerator; };
2002-08-31 00:00:35 +04:00
///! Set the Global Generator, done on creation by the GlobalGenerator
2002-09-04 23:24:49 +04:00
void SetGlobalGenerator(cmGlobalGenerator *gg);
/**
* 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);
///! Call this prior to using Convert
void SetupPathConversions();
/**
* 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);
// flag to determine if this project should be included in a parent project
bool GetExcludeAll()
{
2006-03-15 19:02:08 +03:00
return this->ExcludeFromAll;
}
void SetExcludeAll(bool b)
{
2006-03-15 19:02:08 +03:00
this->ExcludeFromAll = b;
}
///! set/get the parent generator
2006-03-15 19:02:08 +03:00
cmLocalGenerator* GetParent(){return this->Parent;}
void SetParent(cmLocalGenerator* g) { this->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; };
void AddLanguageFlags(std::string& flags, const char* lang,
const char* config);
void AddSharedFlags(std::string& flags, const char* lang, bool shared);
void AddConfigVariableFlags(std::string& flags, const char* var,
const char* config);
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);
/** 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. If the
given name is the full path to a file it will be returned.
Otherwise the name is treated as a relative path with respect to
the source directory of this generator. This should only be
used for dependencies of custom commands. */
std::string GetRealDependency(const char* name, const char* config);
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. */
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. */
2006-03-10 21:54:57 +03:00
virtual bool ScanDependencies(std::vector<std::string> const& /* args */)
{return true;};
2005-05-12 18:49:56 +04: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);
/** Get the include flags for the current makefile and language. */
void GetIncludeDirectories(std::vector<std::string>& dirs);
// Create a struct to hold the varibles passed into
// ExpandRuleVariables
struct RuleVariables
{
RuleVariables()
{
this->Language= 0;
this->Objects= 0;
this->Target= 0;
this->LinkLibraries= 0;
this->Source= 0;
this->Object= 0;
this->ObjectDir= 0;
this->Flags= 0;
this->ObjectsQuoted= 0;
this->TargetSOName= 0;
this->TargetInstallNameDir = 0;
this->LinkFlags= 0;
}
const char* Language;
const char* Objects;
const char* Target;
const char* LinkLibraries;
const char* Source;
const char* Object;
const char* ObjectDir;
const char* Flags;
const char* ObjectsQuoted;
const char* TargetSOName;
const char* TargetInstallNameDir;
const char* LinkFlags;
const char* LanguageCompileFlags;
};
2006-02-20 22:37:24 +03:00
protected:
/** Construct a script from the given list of command lines. */
std::string ConstructScript(const cmCustomCommandLines& commandLines,
const char* workingDirectory,
const char* newline = "\n");
/** Construct a comment for a custom command. */
std::string ConstructComment(const cmCustomCommand& cc,
const char* default_comment = "");
2006-03-10 21:54:57 +03:00
/** Fill out these strings for the given target. Libraries to link,
* flags, and linkflags. */
2006-02-20 22:37:24 +03:00
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
virtual void OutputLinkLibraries(std::ostream&, cmTarget&, bool relink);
// Expand rule variables in CMake of the type found in language rules
void ExpandRuleVariables(std::string& string,
const RuleVariables& replaceValues);
2005-04-12 21:27:07 +04:00
// Expand rule variables in a single string
std::string ExpandRuleVariable(std::string const& variable,
const RuleVariables& replaceValues);
2005-04-12 21:27:07 +04:00
2006-03-10 21:54:57 +03: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&);
// Handle old-style install rules stored in the targets.
void GenerateTargetInstallRules(
std::ostream& os, const char* config,
std::vector<std::string> const& configurationTypes);
2006-03-15 19:02:08 +03:00
cmMakefile *Makefile;
cmGlobalGenerator *GlobalGenerator;
// members used for relative path function ConvertToMakefilePath
2006-03-15 19:02:08 +03:00
std::string RelativePathToSourceDir;
std::string RelativePathToBinaryDir;
std::vector<std::string> HomeDirectoryComponents;
std::vector<std::string> StartDirectoryComponents;
std::vector<std::string> HomeOutputDirectoryComponents;
std::vector<std::string> StartOutputDirectoryComponents;
bool ExcludeFromAll;
cmLocalGenerator* Parent;
std::vector<cmLocalGenerator*> Children;
2006-03-15 19:02:08 +03:00
std::map<cmStdString, cmStdString> LanguageToIncludeFlags;
bool WindowsShell;
bool ForceUnixPath;
bool UseRelativePaths;
bool IgnoreLibPrefix;
bool Configured;
bool EmitUniversalBinaryFlags;
// Hack for ExpandRuleVariable until object-oriented version is
// committed.
2006-03-15 19:02:08 +03:00
std::string TargetImplib;
2002-08-31 00:00:35 +04:00
};
#endif