cmMakefile.h 19 KB
Newer Older
1 2
/*=========================================================================

3
  Program:   CMake - Cross-Platform Makefile Generator
4 5 6 7 8
  Module:    $RCSfile$
  Language:  C++
  Date:      $Date$
  Version:   $Revision$

9 10
  Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  See Copyright.txt or http://www.cmake.org/HTML/Copyright.html 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 "cmSystemTools.h"
23
#include "cmSourceGroup.h"
24
#include "cmTarget.h"
25
#include "cmListFileCache.h"
26 27
#include "cmCacheManager.h"

28
class cmFunctionBlocker;
29
class cmCommand;
Ken Martin's avatar
Ken Martin committed
30
class cmLocalGenerator;
31
class cmMakeDepend;
32
class cmSourceFile;
33
class cmVariableWatch;
34
class cmake;
35

36 37 38 39
/** \class cmMakefile
 * \brief Process the input CMakeLists.txt file.
 *
 * Process and store into memory the input CMakeLists.txt file.
40
 * Each CMakeLists.txt file is parsed and the commands found there
41 42
 * are added into the build process.
 */
43 44 45
class cmMakefile
{
public:
Ken Martin's avatar
Ken Martin committed
46
  /**
47
   * Return major and minor version numbers for cmake.
Ken Martin's avatar
Ken Martin committed
48
   */
49 50 51
  static unsigned int GetMajorVersion() { return CMake_VERSION_MAJOR; }
  static unsigned int GetMinorVersion() { return CMake_VERSION_MINOR; }
  static const char* GetReleaseVersion();
52
  
53 54 55 56 57
  /**
   * 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.
   */
58 59
  unsigned int GetCacheMajorVersion();
  unsigned int GetCacheMinorVersion();
Ken Martin's avatar
Ken Martin committed
60
  
61 62 63
  /**
   * Construct an empty makefile.
   */
Ken Martin's avatar
Ken Martin committed
64
  cmMakefile();
65 66 67 68

  /**
   * Destructor.
   */
Ken Martin's avatar
Ken Martin committed
69
  ~cmMakefile();
70 71 72 73

  /**
   * Read and parse a CMakeLists.txt file.
   */
74
  bool ReadListFile(const char* listfile, const char* external= 0); 
75

76 77 78 79
  /**
   * Add a function blocker to this makefile
   */
  void AddFunctionBlocker(cmFunctionBlocker *fb)
80
    { m_FunctionBlockers.push_back(fb);}
81
  void RemoveFunctionBlocker(cmFunctionBlocker *fb)
82
    { m_FunctionBlockers.remove(fb);}
83
  void RemoveFunctionBlocker(const cmListFileFunction& lff);
84
  
85 86 87 88 89
  /**
   * Try running cmake and building a file. This is used for dynalically
   * loaded commands, not as part of the usual build process.
   */
  int TryCompile(const char *srcdir, const char *bindir, 
90
                 const char *projectName, const char *targetName,
91 92
                 const std::vector<std::string> *cmakeArgs,
                 std::string *output);
93
    
94 95 96 97 98
  /**
   * Specify the makefile generator. This is platform/compiler
   * dependent, although the interface is through a generic
   * superclass.
   */
Ken Martin's avatar
Ken Martin committed
99
  void SetLocalGenerator(cmLocalGenerator*);
100 101
  
  ///! Get the current makefile generator.
Ken Martin's avatar
Ken Martin committed
102 103
  cmLocalGenerator* GetLocalGenerator() 
    { return m_LocalGenerator;}
104 105

  /**
106 107
   * Perform FinalPass, Library dependency analysis etc before output of the
   * makefile.  
108
   */
109
  void ConfigureFinalPass();
110 111 112 113 114 115
  
  /**
   * run the final pass on all commands.
   */
  void FinalPass();
  
116 117 118
  /**
   * Print the object state to std::cout.
   */
119
  void Print() const;
120
  
121
  /**
122
   * Add a custom command to the build.
123
   */
124
  void AddCustomCommand(const char* source,
125
                        const char* command,
Ken Martin's avatar
Ken Martin committed
126
                        const std::vector<std::string>& commandArgs,
127
                        const std::vector<std::string>& depends,
128
                        const std::vector<std::string>& outputs,
129 130
                        const char *target,
                        const char *comment = 0);
131 132 133

  void AddCustomCommand(const char* source,
                        const char* command,
Ken Martin's avatar
Ken Martin committed
134
                        const std::vector<std::string>& commandArgs,
135
                        const std::vector<std::string>& depends,
136 137
                        const char* output,
                        const char* target);
138
  
139 140 141
  /**
   * Add a define flag to the build.
   */
142
  void AddDefineFlag(const char* definition);
143 144 145 146

  /**
   * Add an executable to the build.
   */
147 148 149 150
  void AddExecutable(const char *exename, 
                     const std::vector<std::string> &srcs);
  void AddExecutable(const char *exename, 
                     const std::vector<std::string> &srcs, bool win32);
151

152 153 154 155 156
  /**
   * 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,
157
                         const char* command,
158
                         const char* arguments,
159 160 161
                         bool all);
  void AddUtilityCommand(const char* utilityName,
                         const char* command,
162
                         const char* arguments,
163 164 165
                         bool all,
                         const std::vector<std::string> &depends,
                         const std::vector<std::string> &outputs);
166

167 168 169
  /**
   * Add a link library to the build.
   */
170
  void AddLinkLibrary(const char*);
171 172 173
  void AddLinkLibrary(const char*, cmTarget::LinkLibraryType type);
  void AddLinkLibraryForTarget(const char *tgt, const char*, 
                               cmTarget::LinkLibraryType type);
174
  void AddLinkDirectoryForTarget(const char *tgt, const char* d);
175 176 177 178

  /**
   * Add a link directory to the build.
   */
179
  void AddLinkDirectory(const char*);
180 181 182 183

  /**
   * Add a subdirectory to the build.
   */
184
  void AddSubDirectory(const char*);
185 186 187 188

  /**
   * Add an include directory to the build.
   */
189
  void AddIncludeDirectory(const char*, bool before = false);
190

191 192 193 194 195 196
  /**
   * Find a library (as in cmSystemTools) but add in compiler specific paths
   */
  std::string FindLibrary(const char* name,
                          const std::vector<std::string>& path);

197 198 199 200
  /**
   * Add a variable definition to the build. This variable
   * can be used in CMake to refer to lists, directories, etc.
   */
201
  void AddDefinition(const char* name, const char* value);
202 203 204 205
  ///! 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);
206

207 208 209 210
  /**
   * Add bool variable definition to the build. 
   */
  void AddDefinition(const char* name, bool);
211 212
  ///! Add a definition to this makefile and the global cmake cache.
  void AddCacheDefinition(const char* name, bool, const char* doc);
213

214 215 216 217 218 219
  /**
   * Remove a variable definition from the build.  This is not valid
   * for cache entries, and will only affect the current makefile.
   */
  void RemoveDefinition(const char* name);
  
220 221 222
  /**
   * Specify the name of the project for this build.
   */
223
  void SetProjectName(const char*);
224 225 226 227 228 229 230 231 232 233 234 235

  /**
   * Get the name of the project for this build.
   */
  const char* GetProjectName()
    {
    return m_ProjectName.c_str();
    }
  
  /**
   * Set the name of the library.
   */
236
  void AddLibrary(const char *libname, int shared,
237
                  const std::vector<std::string> &srcs);
238 239 240 241

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

244 245 246
  /**
   * Remove a class/source file from the build.
   */
247
  //void RemoveSource(cmSourceFile& ,const char *srcListName);
248

249 250 251
  /**
   * Add a source group for consideration when adding a new source.
   */
252
  void AddSourceGroup(const char* name, const char* regex=0);
253
  
254 255 256
  /**
   * Add an auxiliary directory to the build.
   */
257 258
  void AddExtraDirectory(const char* dir);
  
Ken Martin's avatar
Ken Martin committed
259 260 261 262 263 264 265 266

  /**
   * Add an auxiliary directory to the build.
   */
  void MakeStartDirectoriesCurrent()
    {
      m_cmCurrentDirectory = m_cmStartDirectory;
      m_CurrentOutputDirectory = m_StartOutputDirectory;
267 268
      this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR", m_cmCurrentDirectory.c_str());
      this->AddDefinition("CMAKE_CURRENT_BINARY_DIR", m_CurrentOutputDirectory.c_str());
Ken Martin's avatar
Ken Martin committed
269 270 271
    }
  
  //@{
272
  /**
Ken Martin's avatar
Ken Martin committed
273 274 275 276 277
   * 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.  
278
   */
279
  void SetHomeDirectory(const char* dir);
280
  const char* GetHomeDirectory() const
281
    {
282
    return m_cmHomeDirectory.c_str();
283
    }
284
  void SetHomeOutputDirectory(const char* lib);
285
  const char* GetHomeOutputDirectory() const
286
    {
Ken Martin's avatar
Ken Martin committed
287
    return m_HomeOutputDirectory.c_str();
288
    }
Ken Martin's avatar
Ken Martin committed
289 290 291
  //@}
  
  //@{
292
  /**
Ken Martin's avatar
Ken Martin committed
293 294 295 296 297
   * 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.  
298
   */
Ken Martin's avatar
Ken Martin committed
299
  void SetStartDirectory(const char* dir) 
300
    {
Ken Martin's avatar
Ken Martin committed
301 302
      m_cmStartDirectory = dir;
      cmSystemTools::ConvertToUnixSlashes(m_cmStartDirectory);
303
    }
304
  const char* GetStartDirectory() const
305
    {
Ken Martin's avatar
Ken Martin committed
306
      return m_cmStartDirectory.c_str();
307
    }
Ken Martin's avatar
Ken Martin committed
308 309 310 311
  void SetStartOutputDirectory(const char* lib)
    {
      m_StartOutputDirectory = lib;
      cmSystemTools::ConvertToUnixSlashes(m_StartOutputDirectory);
Ken Martin's avatar
Ken Martin committed
312
      cmSystemTools::MakeDirectory(m_StartOutputDirectory.c_str());
Ken Martin's avatar
Ken Martin committed
313
    }
314
  const char* GetStartOutputDirectory() const
315
    {
Ken Martin's avatar
Ken Martin committed
316
      return m_StartOutputDirectory.c_str();
317
    }
Ken Martin's avatar
Ken Martin committed
318
  //@}
319

Ken Martin's avatar
Ken Martin committed
320
  //@{
321
  /**
Ken Martin's avatar
Ken Martin committed
322 323 324 325 326
   * 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.  
327
   */
Ken Martin's avatar
Ken Martin committed
328
  void SetCurrentDirectory(const char* dir) 
329
    {
Ken Martin's avatar
Ken Martin committed
330 331
      m_cmCurrentDirectory = dir;
      cmSystemTools::ConvertToUnixSlashes(m_cmCurrentDirectory);
332
      this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR", m_cmCurrentDirectory.c_str());
333
    }
334
  const char* GetCurrentDirectory() const 
Ken Martin's avatar
Ken Martin committed
335 336 337 338 339 340 341
    {
      return m_cmCurrentDirectory.c_str();
    }
  void SetCurrentOutputDirectory(const char* lib)
    {
      m_CurrentOutputDirectory = lib;
      cmSystemTools::ConvertToUnixSlashes(m_CurrentOutputDirectory);
342
      this->AddDefinition("CMAKE_CURRENT_BINARY_DIR", m_CurrentOutputDirectory.c_str());
Ken Martin's avatar
Ken Martin committed
343
    }
344
  const char* GetCurrentOutputDirectory() const
Ken Martin's avatar
Ken Martin committed
345 346 347
    {
      return m_CurrentOutputDirectory.c_str();
    }
348 349 350 351 352 353 354 355 356

  /* 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
357
  //@}
358 359 360 361 362 363 364 365 366 367

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

368 369 370 371 372 373 374 375 376
  /** 
   * 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;
    }

377
  /**
378
   * Get the list of targets
379
   */
Ken Martin's avatar
Ken Martin committed
380
  cmTargets &GetTargets() { return m_Targets; }
381
  const cmTargets &GetTargets() const { return m_Targets; }
382 383 384 385

  /**
   * Get a list of the build subdirectories.
   */
386 387
  const std::vector<std::string>& GetSubDirectories()
    { 
388
    return m_SubDirectories;
389
    }
390 391 392 393

  /**
   * Get a list of include directories in the build.
   */
394
  std::vector<std::string>& GetIncludeDirectories()
395
    { 
396
    return m_IncludeDirectories;
397
    }
398
  const std::vector<std::string>& GetIncludeDirectories() const
399 400 401
    { 
    return m_IncludeDirectories;
    }
402

403 404 405 406 407 408
  /** Expand out any arguements in the vector that have ; separated
   *  strings into multiple arguements.  A new vector is created 
   *  containing the expanded versions of all arguments in argsIn.
   * This method differes from the one in cmSystemTools in that if
   * the CmakeLists file is version 1.2 or earlier it will check for
   * source lists being used without ${} around them
409
   */
410 411
  void ExpandSourceListArguments(std::vector<std::string> const& argsIn,
                                 std::vector<std::string>& argsOut,
Ken Martin's avatar
Ken Martin committed
412
                                 unsigned int startArgumentIndex);
413

414 415 416
  /** Get a cmSourceFile pointer for a given source name, if the name is
   *  not found, then a null pointer is returned.
   */
417
  cmSourceFile* GetSource(const char* sourceName) const;
418 419
  ///! Add a new cmSourceFile to the list of sources for this makefile.
  cmSourceFile* AddSource(cmSourceFile const&);
420
  
421 422 423
  /**
   * Obtain a list of auxiliary source directories.
   */
424
  std::vector<std::string>& GetAuxSourceDirectories()
425
    {return m_AuxSourceDirectories;}
426

427 428 429 430 431 432 433 434 435 436 437
  //@{
  /**
   * 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;}
  //@}

438 439
  /**
   * Given a variable name, return its value (as a string).
440 441
   * If the variable is not found in this makefile instance, the
   * cache is then queried.
442
   */
Ken Martin's avatar
Ken Martin committed
443
  const char* GetDefinition(const char*) const;
444 445 446 447 448 449 450

  /**
   * Get the list of all variables in the current space. If argument
   * cacheonly is specified and is greater than 0, then only cache
   * variables will be listed.
   */
  std::vector<std::string> GetDefinitions(int cacheonly=0) const;
451 452 453 454
  
  /** Test a boolean cache entry to see if it is true or false, 
   *  returns false if no entry defined.
   */
455
  bool IsOn(const char* name) const;
456

457
  /**
458
   * Get a list of preprocessor define flags.
459
   */
460 461
  const char* GetDefineFlags()
    {return m_DefineFlags.c_str();}
462 463 464 465 466 467 468
  
  /**
   * Get the vector of used command instances.
   */
  const std::vector<cmCommand*>& GetUsedCommands() const
    {return m_UsedCommands;}
  
469 470 471 472 473
  /**
   * Get the vector source groups.
   */
  const std::vector<cmSourceGroup>& GetSourceGroups() const
    { return m_SourceGroups; }
474

475 476 477 478 479
  /**
   * Get the source group
   */
  cmSourceGroup* GetSourceGroup(const char* name); 

480 481 482 483 484
  /**
   * Get the vector of list files on which this makefile depends
   */
  const std::vector<std::string>& GetListFiles() const
    { return m_ListFiles; }
485
  
486 487 488 489
  ///! When the file changes cmake will be re-run from the build system.
  void AddCMakeDependFile(const char* file)
    { m_ListFiles.push_back(file);}
  
490
  /**
Bill Hoffman's avatar
Bill Hoffman committed
491 492
   * Expand all defined variables in the string.  
   * Defined variables come from the m_Definitions map.
493
   * They are expanded with ${var} where var is the
494 495
   * entry in the m_Definitions map.  Also @var@ is
   * expanded to match autoconf style expansions.
496
   */
497
  const char *ExpandVariablesInString(std::string& source) const;
498 499
  const char *ExpandVariablesInString(std::string& source, bool escapeQuotes,
                                      bool atOnly = false) const;
500

501 502 503 504
  /**
   * Remove any remaining variables in the string. Anything with ${var} or
   * @var@ will be removed.  
   */
505
  void RemoveVariablesInString(std::string& source, bool atOnly = false) const;
506

507 508 509
  /**
   * Expand variables in the makefiles ivars such as link directories etc
   */
510
  void ExpandVariables();  
511

512 513 514 515 516
  /**
   * find what source group this source is in
   */
  cmSourceGroup& FindSourceGroup(const char* source,
                                 std::vector<cmSourceGroup> &groups);
517 518 519 520
  void RegisterData(cmData*);
  void RegisterData(const char*, cmData*);
  cmData* LookupData(const char*) const;
  
Ken Martin's avatar
Ken Martin committed
521
  /**
522 523
   * Execute a single CMake command.  Returns true if the command
   * succeeded or false if it failed.
Ken Martin's avatar
Ken Martin committed
524
   */
525
  bool ExecuteCommand(const cmListFileFunction& lff);
Ken Martin's avatar
Ken Martin committed
526
  
527 528
  /** Check if a command exists. */
  bool CommandExists(const char* name) const;
Ken Martin's avatar
Ken Martin committed
529
    
530 531 532 533 534
  /**
   * Add a command to this cmake instance
   */
  void AddCommand(cmCommand* );

535 536
  ///! Enable support for the named language, if null then all languages are enabled.
  void EnableLanguage(const char* );
537

538 539 540 541
  /**
   * Set/Get the name of the parent directories CMakeLists file
   * given a current CMakeLists file name
   */
Ken Martin's avatar
Ken Martin committed
542
  cmCacheManager *GetCacheManager() const;
543
  cmVariableWatch* GetVariableWatch() const;
544

545 546 547
  //! Determine wether this is a local or global build.
  bool GetLocal() const;

548 549
  ///! Display progress or status message.
  void DisplayStatus(const char*, float);
550 551 552 553 554 555 556
  
  /**
   * Expand the given list file arguments into the full set after
   * variable replacement and list expansion.
   */
  void ExpandArguments(std::vector<cmListFileArgument> const& inArgs,
                       std::vector<std::string>& outArgs);
557 558 559 560 561
  /**
   * Get the instance
   */ 
  cmake *GetCMakeInstance() const;

562
protected:
563 564 565
  // add link libraries and directories to the target
  void AddGlobalLinkInformation(const char* name, cmTarget& target);
  
566
  std::string m_Prefix;
567
  std::vector<std::string> m_AuxSourceDirectories; // 
Ken Martin's avatar
Ken Martin committed
568 569 570 571 572 573 574

  std::string m_cmCurrentDirectory; 
  std::string m_CurrentOutputDirectory; 
  std::string m_cmStartDirectory; 
  std::string m_StartOutputDirectory; 
  std::string m_cmHomeDirectory; 
  std::string m_HomeOutputDirectory;
575
  std::string m_cmCurrentListFile;
Ken Martin's avatar
Ken Martin committed
576

577
  std::string m_ProjectName;    // project name
578 579 580

  // libraries, classes, and executables
  cmTargets m_Targets;
581
  std::vector<cmSourceFile*> m_SourceFiles;
582

583
  std::vector<std::string> m_SubDirectories; // list of sub directories
584
  struct StringSet : public std::set<cmStdString>
585 586
  {
  };
587
  
588 589 590 591 592
  // 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;
  
593
  std::vector<std::string> m_ListFiles; // list of command files loaded
594 595
  
  
596
  cmTarget::LinkLibraries m_LinkLibraries;
597

598
  std::string m_IncludeFileRegularExpression;
599
  std::string m_ComplainFileRegularExpression;
600 601
  std::vector<std::string> m_SourceFileExtensions;
  std::vector<std::string> m_HeaderFileExtensions;
602
  std::string m_DefineFlags;
603
  std::vector<cmSourceGroup> m_SourceGroups;
604
  typedef std::map<cmStdString, cmStdString> DefinitionMap;
605
  DefinitionMap m_Definitions;
606
  std::vector<cmCommand*> m_UsedCommands;
Ken Martin's avatar
Ken Martin committed
607
  cmLocalGenerator* m_LocalGenerator;
608
  bool IsFunctionBlocked(const cmListFileFunction& lff);
609
  
610
private:
Ken Martin's avatar
Ken Martin committed
611 612 613
  /**
   * Get the name of the parent directories CMakeLists file
   * given a current CMakeLists file name
614
   */
Ken Martin's avatar
Ken Martin committed
615
  std::string GetParentListFileName(const char *listFileName);
616

617
  void ReadSources(std::ifstream& fin, bool t);
618 619
  friend class cmMakeDepend;    // make depend needs direct access 
                                // to the m_Sources array 
620
  void PrintStringVector(const char* s, const std::vector<std::string>& v) const;
621
  void AddDefaultDefinitions();
622
  std::list<cmFunctionBlocker *> m_FunctionBlockers;
623

624
  typedef std::map<cmStdString, cmData*> DataMap;
625
  DataMap m_DataMap;
Ken Martin's avatar
Ken Martin committed
626
  bool m_Inheriting;
627 628 629 630
};


#endif