cmMakefile.h 13.2 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile$
  Language:  C++
  Date:      $Date$
  Version:   $Revision$


  Copyright (c) 2000 National Library of Medicine
  All rights reserved.

  See COPYRIGHT.txt for copyright details.

=========================================================================*/
#ifndef cmMakefile_h
#define cmMakefile_h
18

19
#include "cmStandardIncludes.h"
20
#include "cmClassFile.h"
21
#include "cmSystemTools.h"
22
#include "cmSourceGroup.h"
23
#include "cmTarget.h"
24
class cmFunctionBlocker;
25
class cmCommand;
26
27
class cmMakefileGenerator;

28
29
30
31
/** \class cmMakefile
 * \brief Process the input CMakeLists.txt file.
 *
 * Process and store into memory the input CMakeLists.txt file.
32
 * Each CMakeLists.txt file is parsed and the commands found there
33
34
 * are added into the build process.
 */
35
36
37
class cmMakefile
{
public:
38
39
40
  /**
   * Construct an empty makefile.
   */
41
  cmMakefile();
42
43
44
45

  /**
   * Destructor.
   */
46
  ~cmMakefile();
47
48
49
50

  /**
   * Read and parse a CMakeLists.txt file.
   */
Ken Martin's avatar
Ken Martin committed
51
  bool ReadListFile(const char* listfile); 
52
53
54
55

  /**
   * Add a wrapper generator.
   */
56
  void AddCommand(cmCommand* );
57

58
59
60
61
62
63
64
65
66
  /**
   * Add a function blocker to this makefile
   */
  void AddFunctionBlocker(cmFunctionBlocker *fb)
    { m_FunctionBlockers.insert(fb);}
  void RemoveFunctionBlocker(cmFunctionBlocker *fb)
    { m_FunctionBlockers.erase(fb);}
  void RemoveFunctionBlocker(const char *name, const std::vector<std::string> &args);
  
67
68
69
70
71
  /**
   * Specify the makefile generator. This is platform/compiler
   * dependent, although the interface is through a generic
   * superclass.
   */
72
  void SetMakefileGenerator(cmMakefileGenerator*);
73
74
75
76

  /**
   * Produce the output makefile.
   */
77
78
  void GenerateMakefile();
  
79
80
81
  /**
   * Print the object state to std::cout.
   */
82
  void Print() const;
83
  
84
  /**
85
   * Add a custom command to the build.
86
   */
87
  void AddCustomCommand(const char* source,
88
89
                        const char* command,
                        const std::vector<std::string>& depends,
90
91
                        const std::vector<std::string>& outputs,
                        const char *target);
92
93
94
95

  void AddCustomCommand(const char* source,
                        const char* command,
                        const std::vector<std::string>& depends,
96
97
                        const char* output,
                        const char* target);
98
  
99
100
101
  /**
   * Add a define flag to the build.
   */
102
  void AddDefineFlag(const char* definition);
103
104
105
106

  /**
   * Add an executable to the build.
   */
107
  void AddExecutable(const char *exename, const std::vector<std::string> &srcs);
108

109
  /**
Ken Martin's avatar
Ken Martin committed
110
111
112
   * Add a utility on which this project depends. A utility is an executable
   * name as would be specified to the ADD_EXECUTABLE or UTILITY_SOURCE
   * commands. It is not a full path nor does it have an extension.  
113
114
115
116
117
118
119
120
   */
  void AddUtility(const char*);

  /**
   * Add a directory in which a utility may be built.
   */
  void AddUtilityDirectory(const char*);

121
122
123
  /**
   * Add a link library to the build.
   */
124
  void AddLinkLibrary(const char*);
125
126
127
128

  /**
   * Add a link directory to the build.
   */
129
  void AddLinkDirectory(const char*);
130
131
132
133

  /**
   * Add a subdirectory to the build.
   */
134
  void AddSubDirectory(const char*);
135
136
137
138

  /**
   * Add an include directory to the build.
   */
139
  void AddIncludeDirectory(const char*);
140
141
142
143
144

  /**
   * Add a variable definition to the build. This variable
   * can be used in CMake to refer to lists, directories, etc.
   */
145
  void AddDefinition(const char* name, const char* value);
146

147
148
149
150
151
  /**
   * Add bool variable definition to the build. 
   */
  void AddDefinition(const char* name, bool);

152
153
154
  /**
   * Specify the name of the project for this build.
   */
155
  void SetProjectName(const char*);
156
157
158
159
160
161
162
163
164
165
166
167

  /**
   * Get the name of the project for this build.
   */
  const char* GetProjectName()
    {
    return m_ProjectName.c_str();
    }
  
  /**
   * Set the name of the library.
   */
168
  void AddLibrary(const char *libname, const std::vector<std::string> &srcs);
169
170
171
172

  /**
   * Add a class/source file to the build.
   */
173
  void AddClass(cmClassFile& ,const char *srcListName);
174

175
176
177
178
179
  /**
   * Add a source group for consideration when adding a new source.
   */
  void AddSourceGroup(const char* name, const char* regex);
  
180
181
182
  /**
   * Add an auxiliary directory to the build.
   */
183
184
  void AddExtraDirectory(const char* dir);
  
Ken Martin's avatar
Ken Martin committed
185
186
187
188
189
190
191
192
193
194
195

  /**
   * Add an auxiliary directory to the build.
   */
  void MakeStartDirectoriesCurrent()
    {
      m_cmCurrentDirectory = m_cmStartDirectory;
      m_CurrentOutputDirectory = m_StartOutputDirectory;
    }
  
  //@{
196
  /**
Ken Martin's avatar
Ken Martin committed
197
198
199
200
201
   * Set/Get the home directory (or output directory) in the project. The
   * home directory is the top directory of the project. It is where
   * CMakeSetup or configure was run. Remember that CMake processes
   * CMakeLists files by recursing up the tree starting at the StartDirectory
   * and going up until it reaches the HomeDirectory.  
202
   */
203
204
  void SetHomeDirectory(const char* dir) 
    {
205
206
    m_cmHomeDirectory = dir;
    cmSystemTools::ConvertToUnixSlashes(m_cmHomeDirectory);
207
    this->AddDefinition("CMAKE_SOURCE_DIR", this->GetHomeDirectory());
208
209
210
    }
  const char* GetHomeDirectory() 
    {
211
    return m_cmHomeDirectory.c_str();
212
    }
Ken Martin's avatar
Ken Martin committed
213
  void SetHomeOutputDirectory(const char* lib)
214
    {
Ken Martin's avatar
Ken Martin committed
215
216
    m_HomeOutputDirectory = lib;
    cmSystemTools::ConvertToUnixSlashes(m_HomeOutputDirectory);
217
    this->AddDefinition("CMAKE_BINARY_DIR", this->GetHomeOutputDirectory());
218
    }
Ken Martin's avatar
Ken Martin committed
219
  const char* GetHomeOutputDirectory()
220
    {
Ken Martin's avatar
Ken Martin committed
221
    return m_HomeOutputDirectory.c_str();
222
    }
Ken Martin's avatar
Ken Martin committed
223
224
225
  //@}
  
  //@{
226
  /**
Ken Martin's avatar
Ken Martin committed
227
228
229
230
231
   * Set/Get the start directory (or output directory). The start directory
   * is the directory of the CMakeLists.txt file that started the current
   * round of processing. Remember that CMake processes CMakeLists files by
   * recursing up the tree starting at the StartDirectory and going up until
   * it reaches the HomeDirectory.  
232
   */
Ken Martin's avatar
Ken Martin committed
233
  void SetStartDirectory(const char* dir) 
234
    {
Ken Martin's avatar
Ken Martin committed
235
236
      m_cmStartDirectory = dir;
      cmSystemTools::ConvertToUnixSlashes(m_cmStartDirectory);
237
    }
Ken Martin's avatar
Ken Martin committed
238
  const char* GetStartDirectory() 
239
    {
Ken Martin's avatar
Ken Martin committed
240
      return m_cmStartDirectory.c_str();
241
    }
Ken Martin's avatar
Ken Martin committed
242
243
244
245
246
247
  void SetStartOutputDirectory(const char* lib)
    {
      m_StartOutputDirectory = lib;
      cmSystemTools::ConvertToUnixSlashes(m_StartOutputDirectory);
    }
  const char* GetStartOutputDirectory()
248
    {
Ken Martin's avatar
Ken Martin committed
249
      return m_StartOutputDirectory.c_str();
250
    }
Ken Martin's avatar
Ken Martin committed
251
  //@}
252

Ken Martin's avatar
Ken Martin committed
253
  //@{
254
  /**
Ken Martin's avatar
Ken Martin committed
255
256
257
258
259
   * Set/Get the current directory (or output directory) in the project. The
   * current directory is the directory of the CMakeLists.txt file that is
   * currently being processed. Remember that CMake processes CMakeLists
   * files by recursing up the tree starting at the StartDirectory and going
   * up until it reaches the HomeDirectory.  
260
   */
Ken Martin's avatar
Ken Martin committed
261
  void SetCurrentDirectory(const char* dir) 
262
    {
Ken Martin's avatar
Ken Martin committed
263
264
      m_cmCurrentDirectory = dir;
      cmSystemTools::ConvertToUnixSlashes(m_cmCurrentDirectory);
265
    }
Ken Martin's avatar
Ken Martin committed
266
267
268
269
270
271
272
273
274
275
276
277
278
279
  const char* GetCurrentDirectory() 
    {
      return m_cmCurrentDirectory.c_str();
    }
  void SetCurrentOutputDirectory(const char* lib)
    {
      m_CurrentOutputDirectory = lib;
      cmSystemTools::ConvertToUnixSlashes(m_CurrentOutputDirectory);
    }
  const char* GetCurrentOutputDirectory()
    {
      return m_CurrentOutputDirectory.c_str();
    }
  //@}
280
281
282
283
284
285
286
287
288
289

  /** 
   * Set a regular expression that include files must match
   * in order to be considered as part of the depend information.
   */
  void SetIncludeRegularExpression(const char* regex)
    {
      m_IncludeFileRegularExpression = regex;
    }

290
  /**
291
   * Get the list of targets
292
   */
Ken Martin's avatar
Ken Martin committed
293
  cmTargets &GetTargets() { return m_Targets; }
294
295
296
297

  /**
   * Get a list of the build subdirectories.
   */
298
299
  const std::vector<std::string>& GetSubDirectories()
    { 
300
    return m_SubDirectories;
301
    }
302
303
304
305

  /**
   * Get a list of include directories in the build.
   */
306
307
  std::vector<std::string>& GetIncludeDirectories()
    { 
308
    return m_IncludeDirectories;
309
    }
310
311
312
313

  /**
   * Get a list of link directories in the build.
   */
314
315
  std::vector<std::string>& GetLinkDirectories()
    { 
316
    return m_LinkDirectories;
317
318
    }
  
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
  /**
   * Get a list of utilities on which the project depends.
   */
  std::vector<std::string>& GetUtilities()
    { 
    return m_Utilities;
    }

  /**
   * Get a list of directories that may contain the Utilities.
   */
  std::vector<std::string>& GetUtilityDirectories()
    { 
    return m_UtilityDirectories;
    }

335
336
337
  /**
   * Get a list of link libraries in the build.
   */
338
339
  std::vector<std::string>& GetLinkLibraries()
    { 
340
    return m_LinkLibraries;
341
    }
342
343
344
345

  /**
   * Get a list of Win32 link libraries in the build.
   */
346
347
  std::vector<std::string>& GetLinkLibrariesWin32()
    { 
348
    return m_LinkLibrariesWin32;
349
350
    }
  
351
352
353
  /**
   * Get a list of Unix link libraries in the build.
   */
354
355
  std::vector<std::string>& GetLinkLibrariesUnix()
    { 
356
    return m_LinkLibrariesUnix;
357
    }
358
359
360
361

  /**
   * Return a list of source files in this makefile.
   */
362
363
364
365
366
367
368
369
370
371
372
  typedef std::map<std::string,std::vector<cmClassFile> > ClassMap;
  ClassMap &GetClasses() {return  m_Classes;}
  cmClassFile *GetClass(const char *srclist, const char *className);
  
    
  /**
   * Return a list of classes in the passed source lists
   */
  std::vector<cmClassFile> GetClassesFromSourceLists(
    const std::vector<std::string> &srcLists);
  
373
374
375
  /**
   * Obtain a list of auxiliary source directories.
   */
376
  std::vector<std::string>& GetAuxSourceDirectories()
377
    {return m_AuxSourceDirectories;}
378

379
380
381
382
383
  /**
   * Do not use this.
   */
  std::vector<std::string>& GetMakeVerbatim() 
    {return m_MakeVerbatim;}
384

385
386
  /**
   * Given a variable name, return its value (as a string).
387
   */
388
389
  const char* GetDefinition(const char*);

390
  /**
391
   * Get a list of preprocessor define flags.
392
   */
393
394
  const char* GetDefineFlags()
    {return m_DefineFlags.c_str();}
395
396
397
398
399
400
401
  
  /**
   * Get the vector of used command instances.
   */
  const std::vector<cmCommand*>& GetUsedCommands() const
    {return m_UsedCommands;}
  
402
403
404
405
406
407
  /**
   * Get the vector source groups.
   */
  const std::vector<cmSourceGroup>& GetSourceGroups() const
    { return m_SourceGroups; }
  
408
409
410
411
412
413
  /**
   * Dump documentation to a file. If 0 is returned, the
   * operation failed.
   */
  int DumpDocumentationToFile(const char *fileName);

414
415
416
417
  /**
   * Expand all defined varibles in the string.  
   * Defined varibles come from the m_Definitions map.
   * They are expanded with ${var} where var is the
418
419
   * entry in the m_Definitions map.  Also @var@ is
   * expanded to match autoconf style expansions.
420
   */
421
  void ExpandVariablesInString(std::string& source) const;
422
423
424
425

  /**
   * Expand variables in the makefiles ivars such as link directories etc
   */
426
  void ExpandVariables();  
427
      
Bill Hoffman's avatar
Bill Hoffman committed
428
429
430
431
432
433
434
435
436
437
438
439
440
  /** Recursivly read and create a cmMakefile object for
   *  all CMakeLists.txt files in the GetSubDirectories list.
   *  Once the file is found, it ReadListFile is called on
   *  the cmMakefile created for it.
   */
  void FindSubDirectoryCMakeListsFiles(std::vector<cmMakefile*>& makefiles);
  
  /** Generate the cache file only.  This is done
   *  by calling FindSubDirectoryCMakeListsFiles which
   *  will cause all the rules to fire, and the cache to
   *  be filled.
   */
  void GenerateCacheOnly();
441

442
443
444
445
446
447
  /**
   * find what source group this source is in
   */
  cmSourceGroup& FindSourceGroup(const char* source,
                                 std::vector<cmSourceGroup> &groups);

448
449
protected:
  std::string m_Prefix;
450
  std::vector<std::string> m_AuxSourceDirectories; // 
Ken Martin's avatar
Ken Martin committed
451
452
453
454
455
456
457
458

  std::string m_cmCurrentDirectory; 
  std::string m_CurrentOutputDirectory; 
  std::string m_cmStartDirectory; 
  std::string m_StartOutputDirectory; 
  std::string m_cmHomeDirectory; 
  std::string m_HomeOutputDirectory;

459
  std::string m_ProjectName;	// project name
460
461
462
463
464

  // libraries, classes, and executables
  cmTargets m_Targets;
  ClassMap m_Classes; 

465
  std::vector<std::string> m_SubDirectories; // list of sub directories
466
  std::vector<std::string> m_MakeVerbatim; // lines copied from input file
467
468
  std::vector<std::string> m_IncludeDirectories;
  std::vector<std::string> m_LinkDirectories;
469
470
  std::vector<std::string> m_Utilities;
  std::vector<std::string> m_UtilityDirectories;
471
472
473
  std::vector<std::string> m_LinkLibraries;
  std::vector<std::string> m_LinkLibrariesWin32;
  std::vector<std::string> m_LinkLibrariesUnix;
474
  std::string m_IncludeFileRegularExpression;
475
  std::string m_DefineFlags;
476
  std::vector<cmSourceGroup> m_SourceGroups;
477
  typedef std::map<std::string, cmCommand*> RegisteredCommandsMap;
478
479
  typedef std::map<std::string, std::string> DefinitionMap;
  DefinitionMap m_Definitions;
480
481
  RegisteredCommandsMap m_Commands;
  std::vector<cmCommand*> m_UsedCommands;
482
  cmMakefileGenerator* m_MakefileGenerator;
483
  bool IsFunctionBlocked(const char *name, std::vector<std::string> &args) const;
484
  
485
private:
Ken Martin's avatar
Ken Martin committed
486
487
488
  /**
   * Get the name of the parent directories CMakeLists file
   * given a current CMakeLists file name
489
   */
Ken Martin's avatar
Ken Martin committed
490
  std::string GetParentListFileName(const char *listFileName);
491
492
493
494

  void ReadClasses(std::ifstream& fin, bool t);
  friend class cmMakeDepend;	// make depend needs direct access 
				// to the m_Classes array 
495
  void PrintStringVector(const char* s, const std::vector<std::string>& v) const;
496
  void AddDefaultCommands();
497
  void AddDefaultDefinitions();
498
  std::set<cmFunctionBlocker *> m_FunctionBlockers;
499
500
501
502
};


#endif