CMake/Source/cmMakefileTargetGenerator.h

260 lines
9.0 KiB
C
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#ifndef cmMakefileTargetGenerator_h
#define cmMakefileTargetGenerator_h
#include "cmLocalUnixMakefileGenerator3.h"
class cmCustomCommand;
class cmDependInformation;
class cmDepends;
class cmGeneratedFileStream;
class cmGlobalUnixMakefileGenerator3;
class cmLocalUnixMakefileGenerator3;
class cmMakefile;
class cmTarget;
class cmSourceFile;
/** \class cmMakefileTargetGenerator
* \brief Support Routines for writing makefiles
*
*/
class cmMakefileTargetGenerator
{
public:
2006-02-15 20:32:43 +03:00
// constructor to set the ivars
cmMakefileTargetGenerator(cmTarget* target);
2006-02-15 20:32:43 +03:00
virtual ~cmMakefileTargetGenerator() {};
// construct using this factory call
static cmMakefileTargetGenerator *New(cmTarget *tgt);
/* the main entry point for this class. Writes the Makefiles associated
with this target */
virtual void WriteRuleFiles() = 0;
/* return the number of actions that have progress reporting on them */
virtual unsigned long GetNumberOfProgressActions() {
return this->NumberOfProgressActions;}
std::string GetProgressFileNameFull()
{ return this->ProgressFileNameFull; }
cmTarget* GetTarget() { return this->Target;}
protected:
// create the file and directory etc
void CreateRuleFile();
// outputs the rules for object files and custom commands used by
// this target
void WriteTargetBuildRules();
// write some common code at the top of build.make
void WriteCommonCodeRules();
void WriteTargetLanguageFlags();
// write the provide require rules for this target
void WriteTargetRequiresRules();
// write the clean rules for this target
void WriteTargetCleanRules();
// write the depend rules for this target
void WriteTargetDependRules();
// write rules for Mac OS X Application Bundle content.
void WriteMacOSXContentRules(cmSourceFile& source, const char* pkgloc);
// write the rules for an object
void WriteObjectRuleFiles(cmSourceFile& source);
// write the build rule for an object
void WriteObjectBuildFile(std::string &obj,
const char *lang,
cmSourceFile& source,
std::vector<std::string>& depends);
// write the depend.make file for an object
void WriteObjectDependRules(cmSourceFile& source,
std::vector<std::string>& depends);
// write the build rule for a custom command
void GenerateCustomRuleFile(const cmCustomCommand& cc);
// write a rule to drive building of more than one output from
// another rule
void GenerateExtraOutput(const char* out, const char* in,
bool symbolic = false);
void AppendProgress(std::vector<std::string>& commands);
// write out the variable that lists the objects for this target
void WriteObjectsVariable(std::string& variableName,
std::string& variableNameExternal);
void WriteObjectsString(std::string& buildObjs);
void WriteObjectsStrings(std::vector<std::string>& objStrings,
std::string::size_type limit = std::string::npos);
// write the driver rule to build target outputs
void WriteTargetDriverRule(const char* main_output, bool relink);
void DriveCustomCommands(std::vector<std::string>& depends);
// Return the a string with -F flags on apple
std::string GetFrameworkFlags();
void AppendFortranFormatFlags(std::string& flags, cmSourceFile& source);
// append intertarget dependencies
void AppendTargetDepends(std::vector<std::string>& depends);
// Append link rule dependencies (objects, etc.).
void AppendLinkDepends(std::vector<std::string>& depends);
/** In order to support parallel builds for custom commands with
multiple outputs the outputs are given a serial order, and only
the first output actually has the build rule. Other outputs
just depend on the first one. The check-build-system step must
remove a dependee if the depender is missing to make sure both
are regenerated properly. This method is used by the local
makefile generators to register such pairs. */
void AddMultipleOutputPair(const char* depender, const char* dependee);
/** Create a script to hold link rules and a command to invoke the
script at build time. */
void CreateLinkScript(const char* name,
std::vector<std::string> const& link_commands,
std::vector<std::string>& makefile_commands,
std::vector<std::string>& makefile_depends);
/** Create a response file with the given set of options. Returns
the relative path from the target build working directory to the
response file name. */
std::string CreateResponseFile(const char* name,
std::string const& options,
std::vector<std::string>& makefile_depends);
/** Create lists of object files for linking and cleaning. */
void CreateObjectLists(bool useLinkScript, bool useArchiveRules,
bool useResponseFile, std::string& buildObjs,
std::vector<std::string>& makefile_depends);
void AddIncludeFlags(std::string& flags, const char* lang);
virtual void CloseFileStreams();
void RemoveForbiddenFlags(const char* flagVar, const char* linkLang,
std::string& linkFlags);
cmTarget *Target;
cmLocalUnixMakefileGenerator3 *LocalGenerator;
cmGlobalUnixMakefileGenerator3 *GlobalGenerator;
cmMakefile *Makefile;
const char *ConfigName;
enum CustomCommandDriveType { OnBuild, OnDepends, OnUtility };
CustomCommandDriveType CustomCommandDriver;
// the full path to the build file
std::string BuildFileName;
std::string BuildFileNameFull;
// the full path to the progress file
std::string ProgressFileNameFull;
unsigned long NumberOfProgressActions;
bool NoRuleMessages;
// the path to the directory the build file is in
std::string TargetBuildDirectory;
std::string TargetBuildDirectoryFull;
// the stream for the build file
cmGeneratedFileStream *BuildFileStream;
// the stream for the flag file
std::string FlagFileNameFull;
cmGeneratedFileStream *FlagFileStream;
class StringList: public std::vector<std::string> {};
std::map<cmStdString, StringList> FlagFileDepends;
// the stream for the info file
std::string InfoFileNameFull;
cmGeneratedFileStream *InfoFileStream;
// files to clean
std::vector<std::string> CleanFiles;
// objects used by this target
std::vector<std::string> Objects;
std::vector<std::string> ExternalObjects;
// The windows module definition source file (.def), if any.
std::string ModuleDefinitionFile;
// Set of object file names that will be built in this directory.
2006-03-15 19:02:08 +03:00
std::set<cmStdString> ObjectFiles;
// Set of extra output files to be driven by the build.
std::set<cmStdString> ExtraFiles;
typedef std::map<cmStdString, cmStdString> MultipleOutputPairsType;
MultipleOutputPairsType MultipleOutputPairs;
// Target name info.
std::string TargetNameOut;
std::string TargetNameSO;
std::string TargetNameReal;
std::string TargetNameImport;
std::string TargetNamePDB;
// Mac OS X content info.
std::string MacContentDirectory;
std::set<cmStdString> MacContentFolders;
typedef std::map<cmStdString, cmStdString> ByLanguageMap;
2011-01-13 07:06:25 +03:00
std::string GetFlags(const std::string &l);
ByLanguageMap FlagsByLanguage;
2011-01-13 07:06:25 +03:00
std::string GetDefines(const std::string &l);
ByLanguageMap DefinesByLanguage;
2011-01-13 07:06:25 +03:00
// Target-wide Fortran module output directory.
bool FortranModuleDirectoryComputed;
std::string FortranModuleDirectory;
const char* GetFortranModuleDirectory();
// Compute target-specific Fortran language flags.
void AddFortranFlags(std::string& flags);
// Helper to add flag for windows .def file.
void AddModuleDefinitionFlag(std::string& flags);
// Add language feature flags.
void AddFeatureFlags(std::string& flags, const char* lang);
// Feature query methods.
const char* GetFeature(const char* feature);
bool GetFeatureAsBool(const char* feature);
//==================================================================
// Convenience routines that do nothing more than forward to
// implementaitons
std::string Convert(const char* source,
cmLocalGenerator::RelativeRoot relative,
cmLocalGenerator::OutputFormat output =
cmLocalGenerator::UNCHANGED,
bool optional = false)
{
return this->LocalGenerator->Convert(source, relative, output, optional);
}
};
#endif