cmMakefile.h 15.6 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) 2001 Insight Consortium
All rights reserved.
11

Will Schroeder's avatar
Will Schroeder committed
12
13
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
14

Will Schroeder's avatar
Will Schroeder committed
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 * Redistributions of source code must retain the above copyright notice,
   this list of conditions and the following disclaimer.

 * Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

 * The name of the Insight Consortium, nor the names of any consortium members,
   nor of any contributors, may be used to endorse or promote products derived
   from this software without specific prior written permission.

  * Modified source versions must be plainly marked as such, and must not be
    misrepresented as being the original software.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS''
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39
40
41
42

=========================================================================*/
#ifndef cmMakefile_h
#define cmMakefile_h
43

44
#include "cmStandardIncludes.h"
45
#include "cmData.h"
46
#include "cmSourceFile.h"
47
#include "cmSystemTools.h"
48
#include "cmSourceGroup.h"
49
#include "cmTarget.h"
50
class cmFunctionBlocker;
51
class cmCommand;
52
53
class cmMakefileGenerator;

54
55
56
57
/** \class cmMakefile
 * \brief Process the input CMakeLists.txt file.
 *
 * Process and store into memory the input CMakeLists.txt file.
58
 * Each CMakeLists.txt file is parsed and the commands found there
59
60
 * are added into the build process.
 */
61
62
63
class cmMakefile
{
public:
Ken Martin's avatar
Ken Martin committed
64
65
66
67
68
  /**
   * Return a string version number for CMake 
   */
  static const char *GetVersion() {return "0.1";}
  
69
70
71
  /**
   * Construct an empty makefile.
   */
72
  cmMakefile();
73
74
75
76

  /**
   * Destructor.
   */
77
  ~cmMakefile();
78
79
80
81

  /**
   * Read and parse a CMakeLists.txt file.
   */
Anonymous's avatar
Anonymous committed
82
  bool ReadListFile(const char* listfile, const char* external= 0); 
83
84
85
86

  /**
   * Add a wrapper generator.
   */
87
  void AddCommand(cmCommand* );
88

89
90
91
92
93
94
95
96
97
  /**
   * 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);
  
98
99
100
101
102
  /**
   * Specify the makefile generator. This is platform/compiler
   * dependent, although the interface is through a generic
   * superclass.
   */
103
  void SetMakefileGenerator(cmMakefileGenerator*);
104
105
106
107
  
  ///! Get the current makefile generator.
  cmMakefileGenerator* GetMakefileGenerator() 
    { return m_MakefileGenerator;}
108
109
110
111

  /**
   * Produce the output makefile.
   */
112
113
  void GenerateMakefile();
  
114
115
116
  /**
   * Print the object state to std::cout.
   */
117
  void Print() const;
118
  
119
  /**
120
   * Add a custom command to the build.
121
   */
122
  void AddCustomCommand(const char* source,
123
124
                        const char* command,
                        const std::vector<std::string>& depends,
125
126
                        const std::vector<std::string>& outputs,
                        const char *target);
127
128
129
130

  void AddCustomCommand(const char* source,
                        const char* command,
                        const std::vector<std::string>& depends,
131
132
                        const char* output,
                        const char* target);
133
  
134
135
136
  /**
   * Add a define flag to the build.
   */
137
  void AddDefineFlag(const char* definition);
138
139
140
141

  /**
   * Add an executable to the build.
   */
142
143
144
145
  void AddExecutable(const char *exename, 
                     const std::vector<std::string> &srcs);
  void AddExecutable(const char *exename, 
                     const std::vector<std::string> &srcs, bool win32);
146

147
148
149
150
151
  /**
   * 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,
152
153
154
155
156
157
158
                         const char* command,
                         bool all);
  void AddUtilityCommand(const char* utilityName,
                         const char* command,
                         bool all,
                         const std::vector<std::string> &depends,
                         const std::vector<std::string> &outputs);
159

160
  /**
Ken Martin's avatar
Ken Martin committed
161
162
163
   * 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.  
164
165
166
167
168
169
170
171
   */
  void AddUtility(const char*);

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

172
173
174
  /**
   * Get a list of link libraries in the build.
   */
175
  cmTarget::LinkLibraries& GetLinkLibraries()
176
177
178
179
    { 
    return m_LinkLibraries;
    }

180
181
182
  /**
   * Add a link library to the build.
   */
183
  void AddLinkLibrary(const char*);
184
185
186
  void AddLinkLibrary(const char*, cmTarget::LinkLibraryType type);
  void AddLinkLibraryForTarget(const char *tgt, const char*, 
                               cmTarget::LinkLibraryType type);
187
188
189
190

  /**
   * Add a link directory to the build.
   */
191
  void AddLinkDirectory(const char*);
192
193
194
195

  /**
   * Add a subdirectory to the build.
   */
196
  void AddSubDirectory(const char*);
197
198
199
200

  /**
   * Add an include directory to the build.
   */
201
  void AddIncludeDirectory(const char*);
202
203
204
205
206

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

209
210
211
212
213
  /**
   * Add bool variable definition to the build. 
   */
  void AddDefinition(const char* name, bool);

214
215
216
  /**
   * Specify the name of the project for this build.
   */
217
  void SetProjectName(const char*);
218
219
220
221
222
223
224
225
226
227
228
229

  /**
   * Get the name of the project for this build.
   */
  const char* GetProjectName()
    {
    return m_ProjectName.c_str();
    }
  
  /**
   * Set the name of the library.
   */
230
  void AddLibrary(const char *libname, const std::vector<std::string> &srcs);
231
232
233
234

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

237
238
239
240
241
  /**
   * Add a source group for consideration when adding a new source.
   */
  void AddSourceGroup(const char* name, const char* regex);
  
242
243
244
  /**
   * Add an auxiliary directory to the build.
   */
245
246
  void AddExtraDirectory(const char* dir);
  
Ken Martin's avatar
Ken Martin committed
247
248
249
250
251
252
253
254
255
256
257

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

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

  /* 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
340
  //@}
341
342
343
344
345
346
347
348
349
350

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

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

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

  /**
   * Get a list of include directories in the build.
   */
367
368
  std::vector<std::string>& GetIncludeDirectories()
    { 
369
    return m_IncludeDirectories;
370
    }
371
372
373
374

  /**
   * Get a list of link directories in the build.
   */
375
376
  std::vector<std::string>& GetLinkDirectories()
    { 
377
    return m_LinkDirectories;
378
379
    }
  
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
  /**
   * 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;
    }

396
397
398
  /**
   * Return a list of source files in this makefile.
   */
399
400
401
402
  typedef std::map<std::string,std::vector<cmSourceFile> > SourceMap;
  const SourceMap &GetSources() const {return  m_Sources;}
  SourceMap &GetSources() {return  m_Sources;}
  cmSourceFile *GetSource(const char *srclist, const char *sourceName);
403
  
404
405
406
  /**
   * Obtain a list of auxiliary source directories.
   */
407
  std::vector<std::string>& GetAuxSourceDirectories()
408
    {return m_AuxSourceDirectories;}
409

410
411
412
413
414
  /**
   * Do not use this.
   */
  std::vector<std::string>& GetMakeVerbatim() 
    {return m_MakeVerbatim;}
415

416
417
  /**
   * Given a variable name, return its value (as a string).
418
   */
419
420
  const char* GetDefinition(const char*);

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

  /**
   * Get the vector of list files on which this makefile depends
   */
  const std::vector<std::string>& GetListFiles() const
    { return m_ListFiles; }
444
  
445
446
447
448
449
450
  /**
   * Dump documentation to a file. If 0 is returned, the
   * operation failed.
   */
  int DumpDocumentationToFile(const char *fileName);

451
452
453
454
  /**
   * Expand all defined varibles in the string.  
   * Defined varibles come from the m_Definitions map.
   * They are expanded with ${var} where var is the
455
456
   * entry in the m_Definitions map.  Also @var@ is
   * expanded to match autoconf style expansions.
457
   */
458
  void ExpandVariablesInString(std::string& source) const;
459

460
461
462
463
464
465
  /**
   * Remove any remaining variables in the string. Anything with ${var} or
   * @var@ will be removed.  
   */
  void RemoveVariablesInString(std::string& source) const;

466
467
468
  /**
   * Expand variables in the makefiles ivars such as link directories etc
   */
469
  void ExpandVariables();  
470
      
Bill Hoffman's avatar
Bill Hoffman committed
471
472
473
474
475
476
477
  /** 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);
  
478
479
480
481
482
483
  /**
   * find what source group this source is in
   */
  cmSourceGroup& FindSourceGroup(const char* source,
                                 std::vector<cmSourceGroup> &groups);

484
485
486
487
  void RegisterData(cmData*);
  void RegisterData(const char*, cmData*);
  cmData* LookupData(const char*) const;
  
488
489
protected:
  std::string m_Prefix;
490
  std::vector<std::string> m_AuxSourceDirectories; // 
Ken Martin's avatar
Ken Martin committed
491
492
493
494
495
496
497

  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
498
  std::string m_cmCurrentListFile;
Ken Martin's avatar
Ken Martin committed
499

500
  std::string m_ProjectName;	// project name
501
502
503

  // libraries, classes, and executables
  cmTargets m_Targets;
504
  SourceMap m_Sources; 
505

506
  std::vector<std::string> m_SubDirectories; // list of sub directories
507
  std::vector<std::string> m_MakeVerbatim; // lines copied from input file
508
509
  std::vector<std::string> m_IncludeDirectories;
  std::vector<std::string> m_LinkDirectories;
510
511
  std::vector<std::string> m_Utilities;
  std::vector<std::string> m_UtilityDirectories;
Anonymous's avatar
Anonymous committed
512
513
  std::vector<std::string> m_ListFiles; // list of command files loaded

514
  cmTarget::LinkLibraries m_LinkLibraries;
Anonymous's avatar
Anonymous committed
515

516
  std::string m_IncludeFileRegularExpression;
517
  std::string m_DefineFlags;
518
  std::vector<cmSourceGroup> m_SourceGroups;
519
  typedef std::map<std::string, cmCommand*> RegisteredCommandsMap;
520
521
  typedef std::map<std::string, std::string> DefinitionMap;
  DefinitionMap m_Definitions;
522
523
  RegisteredCommandsMap m_Commands;
  std::vector<cmCommand*> m_UsedCommands;
524
  cmMakefileGenerator* m_MakefileGenerator;
525
  bool IsFunctionBlocked(const char *name, std::vector<std::string> &args) const;
526
  
527
private:
Ken Martin's avatar
Ken Martin committed
528
529
530
  /**
   * Get the name of the parent directories CMakeLists file
   * given a current CMakeLists file name
531
   */
Ken Martin's avatar
Ken Martin committed
532
  std::string GetParentListFileName(const char *listFileName);
533

534
  void ReadSources(std::ifstream& fin, bool t);
535
  friend class cmMakeDepend;	// make depend needs direct access 
536
				// to the m_Sources array 
537
  void PrintStringVector(const char* s, const std::vector<std::string>& v) const;
538
  void AddDefaultCommands();
539
  void AddDefaultDefinitions();
540
  std::set<cmFunctionBlocker *> m_FunctionBlockers;
541
542
543
  
  typedef std::map<std::string, cmData*> DataMap;
  DataMap m_DataMap;
544
545
546
547
};


#endif