cmMakefile.h 17.1 KB
Newer Older
1
2
3
4
5
6
7
8
/*=========================================================================

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

Will Schroeder's avatar
Will Schroeder committed
9
10
  Copyright (c) 2002 Insight Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
11

Will Schroeder's avatar
Will Schroeder committed
12
13
14
     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.
15
16
17
18

=========================================================================*/
#ifndef cmMakefile_h
#define cmMakefile_h
19

20
#include "cmStandardIncludes.h"
21
#include "cmData.h"
22
#include "cmSourceFile.h"
23
#include "cmSystemTools.h"
24
#include "cmSourceGroup.h"
25
#include "cmTarget.h"
26
27
#include "cmCacheManager.h"

28
class cmFunctionBlocker;
29
class cmCommand;
30
class cmMakefileGenerator;
31
class cmMakeDepend;
32

33
34
35
36
/** \class cmMakefile
 * \brief Process the input CMakeLists.txt file.
 *
 * Process and store into memory the input CMakeLists.txt file.
37
 * Each CMakeLists.txt file is parsed and the commands found there
38
39
 * are added into the build process.
 */
40
41
42
class cmMakefile
{
public:
Ken Martin's avatar
Ken Martin committed
43
  /**
44
   * Return major and minor version numbers for cmake.
Ken Martin's avatar
Ken Martin committed
45
   */
Ken Martin's avatar
Ken Martin committed
46
  static unsigned int GetMajorVersion() { return 1;}
Ken Martin's avatar
Ken Martin committed
47
48
  static unsigned int GetMinorVersion() { return 3;}
  static const char *GetReleaseVersion() { return "development";}
49
  
50
51
52
53
54
55
56
  /**
   * Return the major and minor version of the cmake that
   * was used to write the currently loaded cache, note
   * this method will not work before the cache is loaded.
   */
  static unsigned int GetCacheMajorVersion();
  static unsigned int GetCacheMinorVersion();
Ken Martin's avatar
Ken Martin committed
57
  
58
59
60
  /**
   * Construct an empty makefile.
   */
61
  cmMakefile();
62
63
64
65

  /**
   * Destructor.
   */
66
  ~cmMakefile();
67
68
69
70

  /**
   * Read and parse a CMakeLists.txt file.
   */
Anonymous's avatar
Anonymous committed
71
  bool ReadListFile(const char* listfile, const char* external= 0); 
72
73
74
75

  /**
   * Add a wrapper generator.
   */
76
  void AddCommand(cmCommand* );
77

78
79
80
81
82
83
84
85
86
  /**
   * 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);
  
87
88
89
90
91
  /**
   * Specify the makefile generator. This is platform/compiler
   * dependent, although the interface is through a generic
   * superclass.
   */
92
  void SetMakefileGenerator(cmMakefileGenerator*);
93
94
95
96
  
  ///! Get the current makefile generator.
  cmMakefileGenerator* GetMakefileGenerator() 
    { return m_MakefileGenerator;}
97
98
99
100

  /**
   * Produce the output makefile.
   */
101
  void GenerateMakefile();
102
103
104
105
106
107
  
  /**
   * run the final pass on all commands.
   */
  void FinalPass();
  
108
109
110
  /**
   * Print the object state to std::cout.
   */
111
  void Print() const;
112
  
113
  /**
114
   * Add a custom command to the build.
115
   */
116
  void AddCustomCommand(const char* source,
117
                        const char* command,
Ken Martin's avatar
Ken Martin committed
118
                        const std::vector<std::string>& commandArgs,
119
                        const std::vector<std::string>& depends,
120
121
                        const std::vector<std::string>& outputs,
                        const char *target);
122
123
124

  void AddCustomCommand(const char* source,
                        const char* command,
Ken Martin's avatar
Ken Martin committed
125
                        const std::vector<std::string>& commandArgs,
126
                        const std::vector<std::string>& depends,
127
128
                        const char* output,
                        const char* target);
129
  
130
131
132
  /**
   * Add a define flag to the build.
   */
133
  void AddDefineFlag(const char* definition);
134
135
136
137

  /**
   * Add an executable to the build.
   */
138
139
140
141
  void AddExecutable(const char *exename, 
                     const std::vector<std::string> &srcs);
  void AddExecutable(const char *exename, 
                     const std::vector<std::string> &srcs, bool win32);
142

143
144
145
146
147
  /**
   * Add a utility to the build.  A utiltity target is
   * a command that is run every time a target is built.
   */
  void AddUtilityCommand(const char* utilityName,
148
                         const char* command,
149
                         const char* arguments,
150
151
152
                         bool all);
  void AddUtilityCommand(const char* utilityName,
                         const char* command,
153
                         const char* arguments,
154
155
156
                         bool all,
                         const std::vector<std::string> &depends,
                         const std::vector<std::string> &outputs);
157

158
159
160
  /**
   * Add a link library to the build.
   */
161
  void AddLinkLibrary(const char*);
162
163
164
  void AddLinkLibrary(const char*, cmTarget::LinkLibraryType type);
  void AddLinkLibraryForTarget(const char *tgt, const char*, 
                               cmTarget::LinkLibraryType type);
165
  void AddLinkDirectoryForTarget(const char *tgt, const char* d);
166
167
168
169

  /**
   * Add a link directory to the build.
   */
170
  void AddLinkDirectory(const char*);
171
172
173
174

  /**
   * Add a subdirectory to the build.
   */
175
  void AddSubDirectory(const char*);
176
177
178
179

  /**
   * Add an include directory to the build.
   */
180
  void AddIncludeDirectory(const char*, bool before = false);
181
182
183
184
185

  /**
   * Add a variable definition to the build. This variable
   * can be used in CMake to refer to lists, directories, etc.
   */
186
  void AddDefinition(const char* name, const char* value);
187
188
189
190
  ///! Add a definition to this makefile and the global cmake cache.
  void AddCacheDefinition(const char* name, const char* value, 
                          const char* doc,
                          cmCacheManager::CacheEntryType type);
191

192
193
194
195
  /**
   * Add bool variable definition to the build. 
   */
  void AddDefinition(const char* name, bool);
196
197
  ///! Add a definition to this makefile and the global cmake cache.
  void AddCacheDefinition(const char* name, bool, const char* doc);
198

199
200
201
  /**
   * Specify the name of the project for this build.
   */
202
  void SetProjectName(const char*);
203
204
205
206
207
208
209
210
211
212
213
214

  /**
   * Get the name of the project for this build.
   */
  const char* GetProjectName()
    {
    return m_ProjectName.c_str();
    }
  
  /**
   * Set the name of the library.
   */
Yves Starreveld's avatar
 
Yves Starreveld committed
215
  void AddLibrary(const char *libname, int shared,
216
                  const std::vector<std::string> &srcs);
217
218
219
220

  /**
   * Add a class/source file to the build.
   */
221
  void AddSource(cmSourceFile& ,const char *srcListName);
222

223
224
225
226
227
  /**
   * Remove a class/source file from the build.
   */
  void RemoveSource(cmSourceFile& ,const char *srcListName);

228
229
230
231
232
  /**
   * Add a source group for consideration when adding a new source.
   */
  void AddSourceGroup(const char* name, const char* regex);
  
233
234
235
  /**
   * Add an auxiliary directory to the build.
   */
236
237
  void AddExtraDirectory(const char* dir);
  
Ken Martin's avatar
Ken Martin committed
238
239
240
241
242
243
244
245
246
247
248

  /**
   * Add an auxiliary directory to the build.
   */
  void MakeStartDirectoriesCurrent()
    {
      m_cmCurrentDirectory = m_cmStartDirectory;
      m_CurrentOutputDirectory = m_StartOutputDirectory;
    }
  
  //@{
249
  /**
Ken Martin's avatar
Ken Martin committed
250
251
252
253
254
   * 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.  
255
   */
256
  void SetHomeDirectory(const char* dir);
257
  const char* GetHomeDirectory() const
258
    {
259
    return m_cmHomeDirectory.c_str();
260
    }
261
  void SetHomeOutputDirectory(const char* lib);
262
  const char* GetHomeOutputDirectory() const
263
    {
Ken Martin's avatar
Ken Martin committed
264
    return m_HomeOutputDirectory.c_str();
265
    }
Ken Martin's avatar
Ken Martin committed
266
267
268
  //@}
  
  //@{
269
  /**
Ken Martin's avatar
Ken Martin committed
270
271
272
273
274
   * 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.  
275
   */
Ken Martin's avatar
Ken Martin committed
276
  void SetStartDirectory(const char* dir) 
277
    {
Ken Martin's avatar
Ken Martin committed
278
279
      m_cmStartDirectory = dir;
      cmSystemTools::ConvertToUnixSlashes(m_cmStartDirectory);
280
    }
281
  const char* GetStartDirectory() const
282
    {
Ken Martin's avatar
Ken Martin committed
283
      return m_cmStartDirectory.c_str();
284
    }
Ken Martin's avatar
Ken Martin committed
285
286
287
288
  void SetStartOutputDirectory(const char* lib)
    {
      m_StartOutputDirectory = lib;
      cmSystemTools::ConvertToUnixSlashes(m_StartOutputDirectory);
Ken Martin's avatar
Ken Martin committed
289
      cmSystemTools::MakeDirectory(m_StartOutputDirectory.c_str());
Ken Martin's avatar
Ken Martin committed
290
    }
291
  const char* GetStartOutputDirectory() const
292
    {
Ken Martin's avatar
Ken Martin committed
293
      return m_StartOutputDirectory.c_str();
294
    }
Ken Martin's avatar
Ken Martin committed
295
  //@}
296

Ken Martin's avatar
Ken Martin committed
297
  //@{
298
  /**
Ken Martin's avatar
Ken Martin committed
299
300
301
302
303
   * 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.  
304
   */
Ken Martin's avatar
Ken Martin committed
305
  void SetCurrentDirectory(const char* dir) 
306
    {
Ken Martin's avatar
Ken Martin committed
307
308
      m_cmCurrentDirectory = dir;
      cmSystemTools::ConvertToUnixSlashes(m_cmCurrentDirectory);
309
    }
310
  const char* GetCurrentDirectory() const 
Ken Martin's avatar
Ken Martin committed
311
312
313
314
315
316
317
318
    {
      return m_cmCurrentDirectory.c_str();
    }
  void SetCurrentOutputDirectory(const char* lib)
    {
      m_CurrentOutputDirectory = lib;
      cmSystemTools::ConvertToUnixSlashes(m_CurrentOutputDirectory);
    }
319
  const char* GetCurrentOutputDirectory() const
Ken Martin's avatar
Ken Martin committed
320
321
322
    {
      return m_CurrentOutputDirectory.c_str();
    }
Anonymous's avatar
Anonymous committed
323
324
325
326
327
328
329
330
331

  /* Get the current CMakeLists.txt file that is being processed.  This
   * is just used in order to be able to 'branch' from one file to a second
   * transparently */
  const char* GetCurrentListFile() const
    {
      return m_cmCurrentListFile.c_str();
    }

Ken Martin's avatar
Ken Martin committed
332
  //@}
333
334
335
336
337
338
339
340
341
342

  /** 
   * 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;
    }

343
344
345
346
347
348
349
350
351
  /** 
   * Set a regular expression that include files that are not found
   * must match in order to be considered a problem.
   */
  void SetComplainRegularExpression(const char* regex)
    {
      m_ComplainFileRegularExpression = regex;
    }

352
  /**
353
   * Get the list of targets
354
   */
Ken Martin's avatar
Ken Martin committed
355
  cmTargets &GetTargets() { return m_Targets; }
356
  const cmTargets &GetTargets() const { return m_Targets; }
357
358
359
360

  /**
   * Get a list of the build subdirectories.
   */
361
362
  const std::vector<std::string>& GetSubDirectories()
    { 
363
    return m_SubDirectories;
364
    }
365
366
367
368

  /**
   * Get a list of include directories in the build.
   */
369
  std::vector<std::string>& GetIncludeDirectories()
370
    { 
371
    return m_IncludeDirectories;
372
    }
373
  const std::vector<std::string>& GetIncludeDirectories() const
374
375
376
    { 
    return m_IncludeDirectories;
    }
377
378
379
380

  /**
   * Return a list of source files in this makefile.
   */
381
  typedef std::map<cmStdString,std::vector<cmSourceFile*> > SourceMap;
382
383
  const SourceMap &GetSources() const {return  m_Sources;}
  SourceMap &GetSources() {return  m_Sources;}
384
385
386
387
388
389
390
391
  cmSourceFile* GetSource(const char *srclist, const char *sourceName);
  
  /** Get a cmSourceFile pointer for a given source name, if the name is
   *  not found, then a null pointer is returned.
   */
  cmSourceFile* GetSource(const char* sourceName);
  ///! Add a new cmSourceFile to the list of sources for this makefile.
  cmSourceFile* AddSource(cmSourceFile const&);
392
  
393
394
395
  /**
   * Obtain a list of auxiliary source directories.
   */
396
  std::vector<std::string>& GetAuxSourceDirectories()
397
    {return m_AuxSourceDirectories;}
398

399
400
401
402
403
404
405
406
407
408
409
  //@{
  /**
   * Return a list of extensions associated with source and header
   * files
   */
  const std::vector<std::string>& GetSourceExtensions() const
    {return m_SourceFileExtensions;}
  const std::vector<std::string>& GetHeaderExtensions() const
    {return m_HeaderFileExtensions;}
  //@}

410
411
  /**
   * Given a variable name, return its value (as a string).
412
413
   * If the variable is not found in this makefile instance, the
   * cache is then queried.
414
   */
415
  const char* GetDefinition(const char*) const;
416
417
418
419
  
  /** Test a boolean cache entry to see if it is true or false, 
   *  returns false if no entry defined.
   */
420
  bool IsOn(const char* name) const;
421

422
  /**
423
   * Get a list of preprocessor define flags.
424
   */
425
426
  const char* GetDefineFlags()
    {return m_DefineFlags.c_str();}
427
428
429
430
431
432
433
  
  /**
   * Get the vector of used command instances.
   */
  const std::vector<cmCommand*>& GetUsedCommands() const
    {return m_UsedCommands;}
  
434
435
436
437
438
  /**
   * Get the vector source groups.
   */
  const std::vector<cmSourceGroup>& GetSourceGroups() const
    { return m_SourceGroups; }
Anonymous's avatar
Anonymous committed
439
440
441
442
443
444

  /**
   * Get the vector of list files on which this makefile depends
   */
  const std::vector<std::string>& GetListFiles() const
    { return m_ListFiles; }
445
  
446
447
448
449
  ///! When the file changes cmake will be re-run from the build system.
  void AddCMakeDependFile(const char* file)
    { m_ListFiles.push_back(file);}
  
450
451
452
453
  /**
   * Dump documentation to a file. If 0 is returned, the
   * operation failed.
   */
454
  int DumpDocumentationToFile(std::ostream&);
455

456
457
458
459
  /**
   * Expand all defined varibles in the string.  
   * Defined varibles come from the m_Definitions map.
   * They are expanded with ${var} where var is the
460
461
   * entry in the m_Definitions map.  Also @var@ is
   * expanded to match autoconf style expansions.
462
   */
463
  const char *ExpandVariablesInString(std::string& source) const;
464
465
  const char *ExpandVariablesInString(std::string& source, bool escapeQuotes,
                                      bool atOnly = false) const;
466

467
468
469
470
  /**
   * Remove any remaining variables in the string. Anything with ${var} or
   * @var@ will be removed.  
   */
471
  void RemoveVariablesInString(std::string& source, bool atOnly = false) const;
472

473
474
475
  /**
   * Expand variables in the makefiles ivars such as link directories etc
   */
476
  void ExpandVariables();  
477

Bill Hoffman's avatar
Bill Hoffman committed
478
479
480
  /** 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
481
482
483
   *  the cmMakefile created for it.  CreateObject is called on 
   *  the prototype to create a cmMakefileGenerator for each cmMakefile that 
   *  is created.
Bill Hoffman's avatar
Bill Hoffman committed
484
485
486
   */
  void FindSubDirectoryCMakeListsFiles(std::vector<cmMakefile*>& makefiles);
  
487
488
489
490
491
492
  /**
   * find what source group this source is in
   */
  cmSourceGroup& FindSourceGroup(const char* source,
                                 std::vector<cmSourceGroup> &groups);

493
494
495
496
  void RegisterData(cmData*);
  void RegisterData(const char*, cmData*);
  cmData* LookupData(const char*) const;
  
Ken Martin's avatar
Ken Martin committed
497
498
499
  /**
   * execute a single CMake command
   */
500
  void ExecuteCommand(std::string &name, std::vector<std::string> const& args);
Ken Martin's avatar
Ken Martin committed
501
  
502
503
  /** Check if a command exists. */
  bool CommandExists(const char* name) const;
Ken Martin's avatar
Ken Martin committed
504
    
505
506
  ///! Enable support for the named language, if null then all languages are enabled.
  void EnableLanguage(const char* );
507

508
protected:
509
510
511
  // add link libraries and directories to the target
  void AddGlobalLinkInformation(const char* name, cmTarget& target);
  
512
  std::string m_Prefix;
513
  std::vector<std::string> m_AuxSourceDirectories; // 
Ken Martin's avatar
Ken Martin committed
514
515
516
517
518
519
520

  std::string m_cmCurrentDirectory; 
  std::string m_CurrentOutputDirectory; 
  std::string m_cmStartDirectory; 
  std::string m_StartOutputDirectory; 
  std::string m_cmHomeDirectory; 
  std::string m_HomeOutputDirectory;
Anonymous's avatar
Anonymous committed
521
  std::string m_cmCurrentListFile;
Ken Martin's avatar
Ken Martin committed
522

523
  std::string m_ProjectName;	// project name
524
525
526

  // libraries, classes, and executables
  cmTargets m_Targets;
527
  SourceMap m_Sources; 
528
529
  std::vector<cmSourceFile*> m_SourceFiles;
  
530

531
  std::vector<std::string> m_SubDirectories; // list of sub directories
532
  struct StringSet : public std::set<cmStdString>
Bill Hoffman's avatar
Bill Hoffman committed
533
534
  {
  };
535
  
536
537
538
539
540
  // The include and link-library paths.  These may have order
  // dependency, so they must be vectors (not set).
  std::vector<std::string> m_IncludeDirectories;
  std::vector<std::string> m_LinkDirectories;
  
Anonymous's avatar
Anonymous committed
541
  std::vector<std::string> m_ListFiles; // list of command files loaded
542
543
  
  
544
  cmTarget::LinkLibraries m_LinkLibraries;
Anonymous's avatar
Anonymous committed
545

546
  std::string m_IncludeFileRegularExpression;
547
  std::string m_ComplainFileRegularExpression;
548
549
  std::vector<std::string> m_SourceFileExtensions;
  std::vector<std::string> m_HeaderFileExtensions;
550
  std::string m_DefineFlags;
551
  std::vector<cmSourceGroup> m_SourceGroups;
552
553
  typedef std::map<cmStdString, cmCommand*> RegisteredCommandsMap;
  typedef std::map<cmStdString, cmStdString> DefinitionMap;
554
  DefinitionMap m_Definitions;
555
556
  RegisteredCommandsMap m_Commands;
  std::vector<cmCommand*> m_UsedCommands;
557
  cmMakefileGenerator* m_MakefileGenerator;
558
  bool IsFunctionBlocked(const char *name, std::vector<std::string> const& args);
559
  
560
private:
Ken Martin's avatar
Ken Martin committed
561
562
563
  /**
   * Get the name of the parent directories CMakeLists file
   * given a current CMakeLists file name
564
   */
Ken Martin's avatar
Ken Martin committed
565
  std::string GetParentListFileName(const char *listFileName);
566

567
  void ReadSources(std::ifstream& fin, bool t);
568
  friend class cmMakeDepend;	// make depend needs direct access 
569
				// to the m_Sources array 
570
  void PrintStringVector(const char* s, const std::vector<std::string>& v) const;
571
  void AddDefaultCommands();
572
  void AddDefaultDefinitions();
573
  std::set<cmFunctionBlocker *> m_FunctionBlockers;
574
  
575
  typedef std::map<cmStdString, cmData*> DataMap;
576
  DataMap m_DataMap;
Ken Martin's avatar
Ken Martin committed
577
  bool m_Inheriting;
578
579
580
581
};


#endif