Source/cmLocalUnixMakefileGenerator3.h

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmLocalUnixMakefileGenerator3.h,v $
   5   Language:  C++
   6   Date:      $Date: 2009-06-25 13:58:51 $
   7   Version:   $Revision: 1.89 $
   8
   9   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  10   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notices for more information.
  15
  16 =========================================================================*/
  17 #ifndef cmLocalUnixMakefileGenerator3_h
  18 #define cmLocalUnixMakefileGenerator3_h
  19
  20 #include "cmLocalGenerator.h"
  21
  22 class cmCustomCommand;
  23 class cmDependInformation;
  24 class cmDepends;
  25 class cmMakefileTargetGenerator;
  26 class cmTarget;
  27 class cmSourceFile;
  28
  29 /** \class cmLocalUnixMakefileGenerator3
  30  * \brief Write a LocalUnix makefiles.
  31  *
  32  * cmLocalUnixMakefileGenerator3 produces a LocalUnix makefile from its
  33  * member Makefile.
  34  */
  35 class cmLocalUnixMakefileGenerator3 : public cmLocalGenerator
  36 {
  37 public:
  38   cmLocalUnixMakefileGenerator3();
  39   virtual ~cmLocalUnixMakefileGenerator3();
  40
  41   /**
  42    * Process the CMakeLists files for this directory to fill in the
  43    * Makefile ivar
  44    */
  45   virtual void Configure();
  46
  47   /**
  48    * Generate the makefile for this directory.
  49    */
  50   virtual void Generate();
  51
  52
  53   // this returns the relative path between the HomeOutputDirectory and this
  54   // local generators StartOutputDirectory
  55   const std::string &GetHomeRelativeOutputPath();
  56
  57   // Write out a make rule
  58   void WriteMakeRule(std::ostream& os,
  59                      const char* comment,
  60                      const char* target,
  61                      const std::vector<std::string>& depends,
  62                      const std::vector<std::string>& commands,
  63                      bool symbolic,
  64                      bool in_help = false);
  65
  66   // write the main variables used by the makefiles
  67   void WriteMakeVariables(std::ostream& makefileStream);
  68
  69   /**
  70    * If true, then explicitly pass MAKEFLAGS on the make all target for makes
  71    * that do not use environment variables.
  72    *
  73    */
  74   void SetPassMakeflags(bool s){this->PassMakeflags = s;}
  75   bool GetPassMakeflags() { return this->PassMakeflags; }
  76
  77   /**
  78    * Set the flag used to keep the make program silent.
  79    */
  80   void SetMakeSilentFlag(const char* s) { this->MakeSilentFlag = s; }
  81   std::string &GetMakeSilentFlag() { return this->MakeSilentFlag; }
  82
  83   /**
  84    * Set to true if the shell being used is the windows shell.
  85    * This controls if statements in the makefile and the SHELL variable.
  86    * The default is false.
  87    */
  88   void SetWindowsShell(bool v)  {this->WindowsShell = v;}
  89
  90   /**
  91    * Set to true if the make tool being used is Watcom WMake.
  92    */
  93   void SetWatcomWMake(bool v)  {this->WatcomWMake = v;}
  94
  95   /**
  96    * Set to true if the make tool being used is MinGW Make.
  97    */
  98   void SetMinGWMake(bool v)  {this->MinGWMake = v;}
  99
 100   /**
 101    * Set to true if the make tool being used is NMake.
 102    */
 103   void SetNMake(bool v)  {this->NMake = v;}
 104
 105   /**
 106    * Set to true if the shell being used is the MSYS shell.
 107    * This controls if statements in the makefile and the SHELL variable.
 108    * The default is false.
 109    */
 110   void SetMSYSShell(bool v)  {this->MSYSShell = v;}
 111
 112   /**
 113    * If set to true, then NULL is set to nil for non Windows_NT.
 114    * This uses make syntax used by nmake and borland.
 115    * The default is false.
 116    */
 117   void SetDefineWindowsNULL(bool v)  {this->DefineWindowsNULL = v;}
 118
 119   /**
 120    * If set to true, cd dir && command is used to
 121    * run commands in a different directory.
 122    */
 123   void SetUnixCD(bool v)  {this->UnixCD = v;}
 124
 125   /**
 126    * Set Support Verbose Variable.  If true, then .SILENT will
 127    * be not end with :  i.e. .SILENT: or .SILENT
 128    */
 129   void SetSilentNoColon(bool v)  {this->SilentNoColon = v;}
 130
 131   /**
 132    * Set the command to use for native make shell echo.  The value
 133    * should include all parts of the command up to the beginning of
 134    * the message (including a whitespace separator).
 135    */
 136   void SetNativeEchoCommand(const char* cmd, bool isWindows)
 137     { this->NativeEchoCommand = cmd; this->NativeEchoWindows = isWindows; }
 138
 139   /**
 140    * Set the string used to include one makefile into another default
 141    * is include.
 142    */
 143   void SetIncludeDirective(const char* s) { this->IncludeDirective = s; }
 144   const char *GetIncludeDirective() { return this->IncludeDirective.c_str(); }
 145
 146   /**
 147    * Set max makefile variable size, default is 0 which means unlimited.
 148    */
 149   void SetMakefileVariableSize(int s) { this->MakefileVariableSize = s; }
 150
 151   /**
 152    * If ignore lib prefix is true, then do not strip lib from the name
 153    * of a library.
 154    */
 155   void SetIgnoreLibPrefix(bool s) { this->IgnoreLibPrefix = s; }
 156
 157   /**
 158    * Set whether passing a make target on a command line requires an
 159    * extra level of escapes.
 160    */
 161   void SetMakeCommandEscapeTargetTwice(bool b)
 162     { this->MakeCommandEscapeTargetTwice = b; }
 163
 164   /**
 165    * Set whether the Borland curly brace command line hack should be
 166    * applied.
 167    */
 168   void SetBorlandMakeCurlyHack(bool b)
 169     { this->BorlandMakeCurlyHack = b; }
 170
 171   // used in writing out Cmake files such as WriteDirectoryInformation
 172   static void WriteCMakeArgument(std::ostream& os, const char* s);
 173
 174   /** creates the common disclainer text at the top of each makefile */
 175   void WriteDisclaimer(std::ostream& os);
 176
 177   // write a  comment line #====... in the stream
 178   void WriteDivider(std::ostream& os);
 179
 180   /** used to create a recursive make call */
 181   std::string GetRecursiveMakeCall(const char *makefile, const char* tgt);
 182
 183   // append flags to a string
 184   virtual void AppendFlags(std::string& flags, const char* newFlags);
 185
 186   // append an echo command
 187   enum EchoColor { EchoNormal, EchoDepend, EchoBuild, EchoLink,
 188                    EchoGenerate, EchoGlobal };
 189   void AppendEcho(std::vector<std::string>& commands, const char* text,
 190                   EchoColor color = EchoNormal);
 191
 192   /** Get whether the makefile is to have color.  */
 193   bool GetColorMakefile() const { return this->ColorMakefile; }
 194
 195   virtual std::string GetTargetDirectory(cmTarget const& target) const;
 196
 197     // create a command that cds to the start dir then runs the commands
 198   void CreateCDCommand(std::vector<std::string>& commands,
 199                        const char *targetDir,
 200                        cmLocalGenerator::RelativeRoot returnDir);
 201
 202   static std::string ConvertToQuotedOutputPath(const char* p);
 203
 204   std::string CreateMakeVariable(const char* sin, const char* s2in);
 205
 206   /** Called from command-line hook to bring dependencies up to date
 207       for a target.  */
 208   virtual bool UpdateDependencies(const char* tgtInfo,
 209                                   bool verbose, bool color);
 210
 211   /** Called from command-line hook to clear dependencies.  */
 212   virtual void ClearDependencies(cmMakefile* mf, bool verbose);
 213
 214   /** write some extra rules such as make test etc */
 215   void WriteSpecialTargetsTop(std::ostream& makefileStream);
 216   void WriteSpecialTargetsBottom(std::ostream& makefileStream);
 217
 218   std::string GetRelativeTargetDirectory(cmTarget const& target);
 219
 220   // File pairs for implicit dependency scanning.  The key of the map
 221   // is the depender and the value is the explicit dependee.
 222   struct ImplicitDependFileMap: public std::map<cmStdString, cmStdString> {};
 223   struct ImplicitDependLanguageMap:
 224     public std::map<cmStdString, ImplicitDependFileMap> {};
 225   struct ImplicitDependTargetMap:
 226     public std::map<cmStdString, ImplicitDependLanguageMap> {};
 227   ImplicitDependLanguageMap const& GetImplicitDepends(cmTarget const& tgt);
 228
 229   void AddImplicitDepends(cmTarget const& tgt, const char* lang,
 230                           const char* obj, const char* src);
 231
 232   void AppendGlobalTargetDepends(std::vector<std::string>& depends,
 233                                  cmTarget& target);
 234
 235   // write the target rules for the local Makefile into the stream
 236   void WriteLocalAllRules(std::ostream& ruleFileStream);
 237
 238   struct LocalObjectEntry
 239   {
 240     cmTarget* Target;
 241     std::string Language;
 242     LocalObjectEntry(): Target(0), Language() {}
 243     LocalObjectEntry(cmTarget* t, const char* lang):
 244       Target(t), Language(lang) {}
 245   };
 246   struct LocalObjectInfo: public std::vector<LocalObjectEntry>
 247   {
 248     bool HasSourceExtension;
 249   };
 250   std::map<cmStdString, LocalObjectInfo> const& GetLocalObjectFiles()
 251     { return this->LocalObjectFiles;}
 252
 253   std::vector<cmStdString> const& GetLocalHelp() { return this->LocalHelp; }
 254
 255   /** Get whether to create rules to generate preprocessed and
 256       assembly sources.  This could be converted to a variable lookup
 257       later.  */
 258   bool GetCreatePreprocessedSourceRules()
 259     {
 260     return !this->SkipPreprocessedSourceRules;
 261     }
 262   bool GetCreateAssemblySourceRules()
 263     {
 264     return !this->SkipAssemblySourceRules;
 265     }
 266   // Get the directories into which the .o files will go for this target
 267   void GetTargetObjectFileDirectories(cmTarget* target,
 268                                       std::vector<std::string>& dirs);
 269 protected:
 270   void WriteLocalMakefile();
 271
 272
 273   // write the target rules for the local Makefile into the stream
 274   void WriteLocalMakefileTargets(std::ostream& ruleFileStream,
 275                                  std::set<cmStdString> &emitted);
 276
 277   // this method Writes the Directory information files
 278   void WriteDirectoryInformationFile();
 279
 280
 281   // write the depend info
 282   void WriteDependLanguageInfo(std::ostream& cmakefileStream, cmTarget &tgt);
 283
 284   // write the local help rule
 285   void WriteHelpRule(std::ostream& ruleFileStream);
 286
 287   // this converts a file name that is relative to the StartOuputDirectory
 288   // into a full path
 289   std::string ConvertToFullPath(const std::string& localPath);
 290
 291
 292   void WriteConvenienceRule(std::ostream& ruleFileStream,
 293                             const char* realTarget,
 294                             const char* helpTarget);
 295
 296   void WriteTargetDependRule(std::ostream& ruleFileStream,
 297                              cmTarget& target);
 298   void WriteTargetCleanRule(std::ostream& ruleFileStream,
 299                             cmTarget& target,
 300                             const std::vector<std::string>& files);
 301   void WriteTargetRequiresRule(std::ostream& ruleFileStream,
 302                                cmTarget& target,
 303                                const std::vector<std::string>& objects);
 304   void WriteObjectConvenienceRule(std::ostream& ruleFileStream,
 305                                   const char* comment, const char* output,
 306                                   LocalObjectInfo const& info);
 307
 308   std::string GetObjectFileName(cmTarget& target,
 309                                 const cmSourceFile& source,
 310                                 std::string* nameWithoutTargetDir = 0,
 311                                 bool* hasSourceExtension = 0);
 312
 313   void AppendRuleDepend(std::vector<std::string>& depends,
 314                         const char* ruleFileName);
 315   void AppendCustomDepends(std::vector<std::string>& depends,
 316                            const std::vector<cmCustomCommand>& ccs);
 317   void AppendCustomDepend(std::vector<std::string>& depends,
 318                           const cmCustomCommand& cc);
 319   void AppendCustomCommands(std::vector<std::string>& commands,
 320                             const std::vector<cmCustomCommand>& ccs,
 321                             cmTarget* target,
 322                             cmLocalGenerator::RelativeRoot relative =
 323                             cmLocalGenerator::HOME_OUTPUT);
 324   void AppendCustomCommand(std::vector<std::string>& commands,
 325                            const cmCustomCommand& cc,
 326                            cmTarget* target,
 327                            bool echo_comment=false,
 328                            cmLocalGenerator::RelativeRoot relative =
 329                            cmLocalGenerator::HOME_OUTPUT,
 330                            std::ostream* content = 0);
 331   void AppendCleanCommand(std::vector<std::string>& commands,
 332                           const std::vector<std::string>& files,
 333                           cmTarget& target, const char* filename =0);
 334
 335   // Helper methods for dependeny updates.
 336   bool ScanDependencies(const char* targetDir);
 337   void CheckMultipleOutputs(bool verbose);
 338
 339 private:
 340   std::string MakeLauncher(const cmCustomCommand& cc, cmTarget* target,
 341                            RelativeRoot relative);
 342
 343   friend class cmMakefileTargetGenerator;
 344   friend class cmMakefileExecutableTargetGenerator;
 345   friend class cmMakefileLibraryTargetGenerator;
 346   friend class cmMakefileUtilityTargetGenerator;
 347   friend class cmGlobalUnixMakefileGenerator3;
 348
 349   ImplicitDependTargetMap ImplicitDepends;
 350
 351   //==========================================================================
 352   // Configuration settings.
 353   int MakefileVariableSize;
 354   std::string IncludeDirective;
 355   std::string MakeSilentFlag;
 356   std::string ConfigurationName;
 357   std::string NativeEchoCommand;
 358   bool NativeEchoWindows;
 359   bool DefineWindowsNULL;
 360   bool UnixCD;
 361   bool PassMakeflags;
 362   bool SilentNoColon;
 363   bool MakeCommandEscapeTargetTwice;
 364   bool BorlandMakeCurlyHack;
 365   //==========================================================================
 366
 367   std::string HomeRelativeOutputPath;
 368
 369   /* Copy the setting of CMAKE_COLOR_MAKEFILE from the makefile at the
 370      beginning of generation to avoid many duplicate lookups.  */
 371   bool ColorMakefile;
 372
 373   /* Copy the setting of CMAKE_SKIP_PREPROCESSED_SOURCE_RULES and
 374      CMAKE_SKIP_ASSEMBLY_SOURCE_RULES at the beginning of generation to
 375      avoid many duplicate lookups.  */
 376   bool SkipPreprocessedSourceRules;
 377   bool SkipAssemblySourceRules;
 378
 379   std::map<cmStdString, LocalObjectInfo> LocalObjectFiles;
 380   std::vector<cmStdString> LocalHelp;
 381
 382   /* does the work for each target */
 383   std::map<cmStdString, cmStdString> MakeVariableMap;
 384   std::map<cmStdString, cmStdString> ShortMakeVariableMap;
 385 };
 386
 387 #endif