CMake/Source/cmLocalUnixMakefileGenerato...

316 lines
10 KiB
C
Raw Normal View History

Simplify CMake per-source license notices Per-source copyright/license notice headers that spell out copyright holder names and years are hard to maintain and often out-of-date or plain wrong. Precise contributor information is already maintained automatically by the version control tool. Ultimately it is the receiver of a file who is responsible for determining its licensing status, and per-source notices are merely a convenience. Therefore it is simpler and more accurate for each source to have a generic notice of the license name and references to more detailed information on copyright holders and full license terms. Our `Copyright.txt` file now contains a list of Contributors whose names appeared source-level copyright notices. It also references version control history for more precise information. Therefore we no longer need to spell out the list of Contributors in each source file notice. Replace CMake per-source copyright/license notice headers with a short description of the license and links to `Copyright.txt` and online information available from "https://cmake.org/licensing". The online URL also handles cases of modules being copied out of our source into other projects, so we can drop our notices about replacing links with full license text. Run the `Utilities/Scripts/filter-notices.bash` script to perform the majority of the replacements mechanically. Manually fix up shebang lines and trailing newlines in a few files. Manually update the notices in a few files that the script does not handle.
2016-09-27 22:01:08 +03:00
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
2005-05-05 20:45:53 +04:00
#ifndef cmLocalUnixMakefileGenerator3_h
#define cmLocalUnixMakefileGenerator3_h
#include <cmConfigure.h>
2005-05-05 20:45:53 +04:00
#include "cmDepends.h"
#include "cmLocalCommonGenerator.h"
#include <iosfwd>
#include <map>
#include <set>
#include <string>
#include <vector>
2005-05-05 20:45:53 +04:00
class cmCustomCommand;
class cmCustomCommandGenerator;
class cmGeneratorTarget;
class cmGlobalGenerator;
class cmMakefile;
2005-05-05 20:45:53 +04:00
class cmSourceFile;
/** \class cmLocalUnixMakefileGenerator3
* \brief Write a LocalUnix makefiles.
*
* cmLocalUnixMakefileGenerator3 produces a LocalUnix makefile from its
2006-03-15 19:02:08 +03:00
* member Makefile.
2005-05-05 20:45:53 +04:00
*/
class cmLocalUnixMakefileGenerator3 : public cmLocalCommonGenerator
2005-05-05 20:45:53 +04:00
{
public:
cmLocalUnixMakefileGenerator3(cmGlobalGenerator* gg, cmMakefile* mf);
2016-06-27 22:25:27 +03:00
~cmLocalUnixMakefileGenerator3() CM_OVERRIDE;
2005-05-05 20:45:53 +04:00
2016-06-27 22:25:27 +03:00
void ComputeHomeRelativeOutputPath() CM_OVERRIDE;
/**
2011-10-13 21:51:18 +04:00
* Generate the makefile for this directory.
*/
2016-06-27 22:25:27 +03:00
void Generate() CM_OVERRIDE;
2005-05-06 22:49:38 +04:00
// this returns the relative path between the HomeOutputDirectory and this
// local generators StartOutputDirectory
const std::string& GetHomeRelativeOutputPath();
2005-05-06 22:49:38 +04:00
2011-10-13 21:51:18 +04:00
// Write out a make rule
void WriteMakeRule(std::ostream& os, const char* comment,
2014-02-07 02:31:47 +04:00
const std::string& target,
2005-05-06 22:49:38 +04:00
const std::vector<std::string>& depends,
const std::vector<std::string>& commands, bool symbolic,
bool in_help = false);
2011-10-13 21:51:18 +04:00
2005-05-06 22:49:38 +04:00
// write the main variables used by the makefiles
2005-08-06 01:07:07 +04:00
void WriteMakeVariables(std::ostream& makefileStream);
2005-05-06 22:49:38 +04:00
2005-05-05 20:45:53 +04:00
/**
* Set max makefile variable size, default is 0 which means unlimited.
*/
2006-03-15 19:02:08 +03:00
void SetMakefileVariableSize(int s) { this->MakefileVariableSize = s; }
2005-05-05 20:45:53 +04:00
/**
* Set whether passing a make target on a command line requires an
* extra level of escapes.
*/
void SetMakeCommandEscapeTargetTwice(bool b)
{
this->MakeCommandEscapeTargetTwice = b;
}
/**
* Set whether the Borland curly brace command line hack should be
* applied.
*/
void SetBorlandMakeCurlyHack(bool b) { this->BorlandMakeCurlyHack = b; }
// used in writing out Cmake files such as WriteDirectoryInformation
static void WriteCMakeArgument(std::ostream& os, const char* s);
2011-03-19 13:41:00 +03:00
/** creates the common disclaimer text at the top of each makefile */
void WriteDisclaimer(std::ostream& os);
// write a comment line #====... in the stream
void WriteDivider(std::ostream& os);
/** used to create a recursive make call */
std::string GetRecursiveMakeCall(const char* makefile,
2014-02-07 02:31:47 +04:00
const std::string& tgt);
2011-10-13 21:51:18 +04:00
2007-05-10 22:43:55 +04:00
// append flags to a string
2016-06-27 22:25:27 +03:00
void AppendFlags(std::string& flags,
const std::string& newFlags) CM_OVERRIDE;
void AppendFlags(std::string& flags, const char* newFlags) CM_OVERRIDE;
2007-05-10 22:43:55 +04:00
// append an echo command
enum EchoColor
{
EchoNormal,
EchoDepend,
EchoBuild,
EchoLink,
EchoGenerate,
EchoGlobal
};
struct EchoProgress
{
std::string Dir;
std::string Arg;
};
void AppendEcho(std::vector<std::string>& commands, std::string const& text,
2016-06-27 23:44:16 +03:00
EchoColor color = EchoNormal,
EchoProgress const* = CM_NULLPTR);
/** Get whether the makefile is to have color. */
bool GetColorMakefile() const { return this->ColorMakefile; }
2016-06-27 22:25:27 +03:00
std::string GetTargetDirectory(cmGeneratorTarget const* target) const
CM_OVERRIDE;
// create a command that cds to the start dir then runs the commands
2011-10-13 21:51:18 +04:00
void CreateCDCommand(std::vector<std::string>& commands,
const char* targetDir, std::string const& relDir);
static std::string ConvertToQuotedOutputPath(const char* p,
bool useWatcomQuote);
std::string CreateMakeVariable(const std::string& sin,
const std::string& s2in);
/** Called from command-line hook to bring dependencies up to date
for a target. */
2016-06-27 22:25:27 +03:00
bool UpdateDependencies(const char* tgtInfo, bool verbose,
bool color) CM_OVERRIDE;
/** Called from command-line hook to clear dependencies. */
2016-06-27 22:25:27 +03:00
void ClearDependencies(cmMakefile* mf, bool verbose) CM_OVERRIDE;
2011-10-13 21:51:18 +04:00
/** write some extra rules such as make test etc */
2005-05-06 22:49:38 +04:00
void WriteSpecialTargetsTop(std::ostream& makefileStream);
2005-05-05 20:45:53 +04:00
void WriteSpecialTargetsBottom(std::ostream& makefileStream);
std::string GetRelativeTargetDirectory(cmGeneratorTarget* target);
2005-05-05 20:45:53 +04:00
// File pairs for implicit dependency scanning. The key of the map
// is the depender and the value is the explicit dependee.
struct ImplicitDependFileMap
: public std::map<std::string, cmDepends::DependencyVector>
{
};
struct ImplicitDependLanguageMap
: public std::map<std::string, ImplicitDependFileMap>
{
};
struct ImplicitDependTargetMap
: public std::map<std::string, ImplicitDependLanguageMap>
{
};
ImplicitDependLanguageMap const& GetImplicitDepends(
cmGeneratorTarget const* tgt);
2015-10-19 00:20:47 +03:00
void AddImplicitDepends(cmGeneratorTarget const* tgt,
const std::string& lang, const char* obj,
const char* src);
// write the target rules for the local Makefile into the stream
void WriteLocalAllRules(std::ostream& ruleFileStream);
2011-10-13 21:51:18 +04:00
std::vector<std::string> const& GetLocalHelp() { return this->LocalHelp; }
/** Get whether to create rules to generate preprocessed and
assembly sources. This could be converted to a variable lookup
later. */
bool GetCreatePreprocessedSourceRules()
{
return !this->SkipPreprocessedSourceRules;
}
bool GetCreateAssemblySourceRules()
{
return !this->SkipAssemblySourceRules;
}
2011-10-13 21:51:18 +04:00
// Fill the vector with the target names for the object files,
// preprocessed files and assembly files. Currently only used by the
// Eclipse generator.
void GetIndividualFileTargets(std::vector<std::string>& targets);
2011-10-13 21:51:18 +04:00
2005-05-05 20:45:53 +04:00
protected:
void WriteLocalMakefile();
2011-10-13 21:51:18 +04:00
2005-05-11 16:45:16 +04:00
// write the target rules for the local Makefile into the stream
void WriteLocalMakefileTargets(std::ostream& ruleFileStream,
std::set<std::string>& emitted);
// this method Writes the Directory information files
void WriteDirectoryInformationFile();
2011-10-13 21:51:18 +04:00
// write the depend info
void WriteDependLanguageInfo(std::ostream& cmakefileStream,
cmGeneratorTarget* tgt);
2011-10-13 21:51:18 +04:00
// write the local help rule
void WriteHelpRule(std::ostream& ruleFileStream);
2011-10-13 21:51:18 +04:00
// this converts a file name that is relative to the StartOuputDirectory
// into a full path
std::string ConvertToFullPath(const std::string& localPath);
2005-05-06 22:49:38 +04:00
void WriteConvenienceRule(std::ostream& ruleFileStream,
2014-02-07 02:31:47 +04:00
const std::string& realTarget,
const std::string& helpTarget);
2005-05-17 19:15:09 +04:00
void WriteTargetDependRule(std::ostream& ruleFileStream,
2015-10-19 00:20:47 +03:00
cmGeneratorTarget* target);
void WriteTargetCleanRule(std::ostream& ruleFileStream,
2015-10-19 00:20:47 +03:00
cmGeneratorTarget* target,
const std::vector<std::string>& files);
2005-05-11 16:45:16 +04:00
void WriteTargetRequiresRule(std::ostream& ruleFileStream,
2015-10-19 00:20:47 +03:00
cmGeneratorTarget* target,
2005-05-17 19:15:09 +04:00
const std::vector<std::string>& objects);
2011-10-13 21:51:18 +04:00
2005-05-05 20:45:53 +04:00
void AppendRuleDepend(std::vector<std::string>& depends,
const char* ruleFileName);
void AppendRuleDepends(std::vector<std::string>& depends,
std::vector<std::string> const& ruleFiles);
2005-05-05 20:45:53 +04:00
void AppendCustomDepends(std::vector<std::string>& depends,
const std::vector<cmCustomCommand>& ccs);
void AppendCustomDepend(std::vector<std::string>& depends,
cmCustomCommandGenerator const& cc);
void AppendCustomCommands(std::vector<std::string>& commands,
const std::vector<cmCustomCommand>& ccs,
cmGeneratorTarget* target,
std::string const& relative);
void AppendCustomCommand(std::vector<std::string>& commands,
cmCustomCommandGenerator const& ccg,
cmGeneratorTarget* target,
std::string const& relative,
bool echo_comment = false,
std::ostream* content = CM_NULLPTR);
2005-05-05 20:45:53 +04:00
void AppendCleanCommand(std::vector<std::string>& commands,
const std::vector<std::string>& files,
2016-06-27 23:44:16 +03:00
cmGeneratorTarget* target,
const char* filename = CM_NULLPTR);
2005-05-05 20:45:53 +04:00
// Helper methods for dependeny updates.
bool ScanDependencies(
const char* targetDir,
std::map<std::string, cmDepends::DependencyVector>& validDeps);
void CheckMultipleOutputs(bool verbose);
2005-05-05 20:45:53 +04:00
private:
std::string MaybeConvertWatcomShellCommand(std::string const& cmd);
2016-06-27 22:25:27 +03:00
void ComputeObjectFilenames(
std::map<cmSourceFile const*, std::string>& mapping,
2016-06-27 23:44:16 +03:00
cmGeneratorTarget const* gt = CM_NULLPTR) CM_OVERRIDE;
friend class cmMakefileTargetGenerator;
friend class cmMakefileExecutableTargetGenerator;
friend class cmMakefileLibraryTargetGenerator;
friend class cmMakefileUtilityTargetGenerator;
2006-05-23 17:11:46 +04:00
friend class cmGlobalUnixMakefileGenerator3;
ImplicitDependTargetMap ImplicitDepends;
2005-05-05 20:45:53 +04:00
2006-03-15 19:02:08 +03:00
std::string HomeRelativeOutputPath;
struct LocalObjectEntry
{
cmGeneratorTarget* Target;
std::string Language;
LocalObjectEntry()
2016-06-27 23:44:16 +03:00
: Target(CM_NULLPTR)
, Language()
{
}
LocalObjectEntry(cmGeneratorTarget* t, const std::string& lang)
: Target(t)
, Language(lang)
{
}
};
struct LocalObjectInfo : public std::vector<LocalObjectEntry>
{
bool HasSourceExtension;
bool HasPreprocessRule;
bool HasAssembleRule;
LocalObjectInfo()
: HasSourceExtension(false)
, HasPreprocessRule(false)
, HasAssembleRule(false)
{
}
};
void GetLocalObjectFiles(
std::map<std::string, LocalObjectInfo>& localObjectFiles);
void WriteObjectConvenienceRule(std::ostream& ruleFileStream,
const char* comment, const char* output,
LocalObjectInfo const& info);
std::vector<std::string> LocalHelp;
/* does the work for each target */
std::map<std::string, std::string> MakeVariableMap;
std::map<std::string, std::string> ShortMakeVariableMap;
int MakefileVariableSize;
bool MakeCommandEscapeTargetTwice;
bool BorlandMakeCurlyHack;
bool ColorMakefile;
bool SkipPreprocessedSourceRules;
bool SkipAssemblySourceRules;
2005-05-05 20:45:53 +04:00
};
#endif