1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
/*=========================================================================
Program: CMake - Cross-Platform Makefile Generator
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.
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 cmLocalUnixMakefileGenerator2_h
#define cmLocalUnixMakefileGenerator2_h
#include "cmLocalUnixMakefileGenerator.h"
class cmCustomCommand;
class cmDependInformation;
class cmMakeDepend;
class cmTarget;
class cmSourceFile;
/** \class cmLocalUnixMakefileGenerator2
* \brief Write a LocalUnix makefiles.
*
* cmLocalUnixMakefileGenerator2 produces a LocalUnix makefile from its
* member m_Makefile.
*/
class cmLocalUnixMakefileGenerator2 : public cmLocalUnixMakefileGenerator
{
public:
///! Set cache only and recurse to false by default.
cmLocalUnixMakefileGenerator2();
virtual ~cmLocalUnixMakefileGenerator2();
/** Set the command used when there are no dependencies or rules for
a target. This is used to avoid errors on some make
implementations. */
void SetEmptyCommand(const char* cmd);
/**
* Generate the makefile for this directory. fromTheTop indicates if this
* is being invoked as part of a global Generate or specific to this
* directory. The difference is that when done from the Top we might skip
* some steps to save time, such as dependency generation for the
* makefiles. This is done by a direct invocation from make.
*/
virtual void Generate(bool fromTheTop);
/** Called from command-line hook to scan dependencies. */
static bool ScanDependencies(std::vector<std::string> const& args);
/** Called from command-line hook to check dependencies. */
static void CheckDependencies(const char* depCheck);
protected:
void GenerateMakefile();
void GenerateCMakefile();
void GenerateTargetRuleFile(const cmTarget& target);
void GenerateObjectRuleFile(const cmTarget& target,
const cmSourceFile& source);
void GenerateCustomRuleFile(const cmSourceFile& source);
std::string GenerateDependsMakeFile(const char* file);
void WriteMakeRule(std::ostream& os,
const char* comment,
const char* preEcho,
const char* target,
const std::vector<std::string>& depends,
const std::vector<std::string>& commands,
const char* postEcho=0);
void WriteDivider(std::ostream& os);
void WriteDisclaimer(std::ostream& os);
void WriteMakeVariables(std::ostream& makefileStream);
void WriteSpecialTargetsTop(std::ostream& makefileStream);
void WriteSpecialTargetsBottom(std::ostream& makefileStream);
void WriteRuleFileIncludes(std::ostream& makefileStream);
void WriteAllRule(std::ostream& makefileStream);
void WriteSubdirRules(std::ostream& makefileStream, const char* pass);
void WriteSubdirRule(std::ostream& makefileStream, const char* pass,
const char* subdir, std::string& last);
void WriteSubdirDriverRule(std::ostream& makefileStream, const char* pass,
const char* order, const std::string& last);
void WriteRequiresRule(std::ostream& ruleFileStream, const cmTarget& target,
const char* targetFullPath);
void WriteConvenienceRules(std::ostream& ruleFileStream,
const cmTarget& target,
const char* targetFullPath);
void WriteConvenienceRule(std::ostream& ruleFileStream,
const char* realTarget,
const char* helpTarget);
void WriteExecutableRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
std::vector<std::string>& objects);
void WriteStaticLibraryRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
std::vector<std::string>& objects);
void WriteSharedLibraryRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
std::vector<std::string>& objects);
void WriteModuleLibraryRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
std::vector<std::string>& objects);
void WriteLibraryRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
std::vector<std::string>& objects,
const char* linkRuleVar,
const char* extraLinkFlags);
std::string GetTargetDirectory(const cmTarget& target);
std::string GetSubdirTargetName(const char* pass, const char* subdir);
std::string GetObjectFileName(const cmTarget& target,
const cmSourceFile& source);
std::string GetCustomBaseName(const cmCustomCommand& cc);
const char* GetSourceFileLanguage(const cmSourceFile& source);
std::string ConvertToFullPath(const std::string& localPath);
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);
void AppendLibDepends(const cmTarget& target,
std::vector<std::string>& depends);
void AppendLibDepend(std::vector<std::string>& depends, const char* name);
std::string GetRecursiveMakeCall(const char* tgt, bool silent);
void WriteJumpAndBuildRules(std::ostream& makefileStream);
static bool ScanDependenciesC(const char* objFile, const char* srcFile,
std::vector<std::string> const& includes);
static void CheckDependencies(const char* dir, const char* file);
static void WriteEmptyDependMakeFile(const char* file,
const char* depMarkFileFull,
const char* depMakeFileFull);
private:
// Map from target name to build directory containing it for
// jump-and-build targets.
struct RemoteTarget
{
std::string m_BuildDirectory;
std::string m_FilePath;
};
std::map<cmStdString, RemoteTarget> m_JumpAndBuild;
// List the files for which to check dependency integrity.
std::set<cmStdString> m_CheckDependFiles;
// Command used when a rule has no dependencies or commands.
std::vector<std::string> m_EmptyCommands;
// List of make rule files that need to be included by the makefile.
std::vector<std::string> m_IncludeRuleFiles;
// Set of custom rule files that have been generated.
std::set<cmStdString> m_CustomRuleFiles;
};
#endif
|
