1 files changed, 287 insertions, 0 deletions
diff --git a/Source/cmMakefileTargetGenerator.h b/Source/cmMakefileTargetGenerator.h
new file mode 100644
index 0000000..9fac574
--- /dev/null
+++ b/Source/cmMakefileTargetGenerator.h
@@ -0,0 +1,287 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+
+  Distributed under the OSI-approved BSD License (the "License");
+  see accompanying file Copyright.txt for details.
+
+  This software is distributed WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the License for more information.
+============================================================================*/
+#ifndef cmMakefileTargetGenerator_h
+#define cmMakefileTargetGenerator_h
+
+#include "cmLocalUnixMakefileGenerator3.h"
+#include "cmOSXBundleGenerator.h"
+
+class cmCustomCommandGenerator;
+class cmDependInformation;
+class cmDepends;
+class cmGeneratorTarget;
+class cmGeneratedFileStream;
+class cmGlobalUnixMakefileGenerator3;
+class cmLocalUnixMakefileGenerator3;
+class cmMakefile;
+class cmTarget;
+class cmSourceFile;
+
+/** \class cmMakefileTargetGenerator
+ * \brief Support Routines for writing makefiles
+ *
+ */
+class cmMakefileTargetGenerator
+{
+public:
+  // constructor to set the ivars
+  cmMakefileTargetGenerator(cmTarget* target);
+  virtual ~cmMakefileTargetGenerator();
+
+  // construct using this factory call
+  static cmMakefileTargetGenerator *New(cmGeneratorTarget *tgt);
+
+  /* the main entry point for this class. Writes the Makefiles associated
+     with this target */
+  virtual void WriteRuleFiles() = 0;
+
+  /* return the number of actions that have progress reporting on them */
+  virtual unsigned long GetNumberOfProgressActions() {
+    return this->NumberOfProgressActions;}
+  std::string GetProgressFileNameFull()
+    { return this->ProgressFileNameFull; }
+
+  cmTarget* GetTarget() { return this->Target;}
+
+protected:
+
+  // create the file and directory etc
+  void CreateRuleFile();
+
+  // outputs the rules for object files and custom commands used by
+  // this target
+  void WriteTargetBuildRules();
+
+  // write some common code at the top of build.make
+  void WriteCommonCodeRules();
+  void WriteTargetLanguageFlags();
+
+  // write the provide require rules for this target
+  void WriteTargetRequiresRules();
+
+  // write the clean rules for this target
+  void WriteTargetCleanRules();
+
+  // write the depend rules for this target
+  void WriteTargetDependRules();
+
+  // write rules for Mac OS X Application Bundle content.
+  struct MacOSXContentGeneratorType :
+    cmOSXBundleGenerator::MacOSXContentGeneratorType
+  {
+    MacOSXContentGeneratorType(cmMakefileTargetGenerator* gen) :
+      Generator(gen) {}
+
+    void operator()(cmSourceFile const& source, const char* pkgloc);
+
+  private:
+    cmMakefileTargetGenerator* Generator;
+  };
+  friend struct MacOSXContentGeneratorType;
+
+  // write the rules for an object
+  void WriteObjectRuleFiles(cmSourceFile const& source);
+
+  // write the build rule for an object
+  void WriteObjectBuildFile(std::string &obj,
+                            const std::string& lang,
+                            cmSourceFile const& source,
+                            std::vector<std::string>& depends);
+
+  // write the depend.make file for an object
+  void WriteObjectDependRules(cmSourceFile const& source,
+                              std::vector<std::string>& depends);
+
+  // write the build rule for a custom command
+  void GenerateCustomRuleFile(cmCustomCommandGenerator const& ccg);
+
+  // write a rule to drive building of more than one output from
+  // another rule
+  void GenerateExtraOutput(const char* out, const char* in,
+                           bool symbolic = false);
+
+  void AppendProgress(std::vector<std::string>& commands);
+
+  // write out the variable that lists the objects for this target
+  void WriteObjectsVariable(std::string& variableName,
+                            std::string& variableNameExternal,
+                            bool useWatcomQuote);
+  void WriteObjectsString(std::string& buildObjs);
+  void WriteObjectsStrings(std::vector<std::string>& objStrings,
+                           std::string::size_type limit = std::string::npos);
+
+  // write the driver rule to build target outputs
+  void WriteTargetDriverRule(const std::string& main_output, bool relink);
+
+  void DriveCustomCommands(std::vector<std::string>& depends);
+
+  // Return the a string with -F flags on apple
+  std::string GetFrameworkFlags(std::string const& l);
+
+  void AppendFortranFormatFlags(std::string& flags,
+                                cmSourceFile const& source);
+
+  // append intertarget dependencies
+  void AppendTargetDepends(std::vector<std::string>& depends);
+
+  // Append object file dependencies.
+  void AppendObjectDepends(std::vector<std::string>& depends);
+
+  // Append link rule dependencies (objects, etc.).
+  void AppendLinkDepends(std::vector<std::string>& depends);
+
+  // Lookup the link rule for this target.
+  std::string GetLinkRule(const std::string& linkRuleVar);
+
+  /** In order to support parallel builds for custom commands with
+      multiple outputs the outputs are given a serial order, and only
+      the first output actually has the build rule.  Other outputs
+      just depend on the first one.  The check-build-system step must
+      remove a dependee if the depender is missing to make sure both
+      are regenerated properly.  This method is used by the local
+      makefile generators to register such pairs.  */
+  void AddMultipleOutputPair(const char* depender, const char* dependee);
+
+  /** Create a script to hold link rules and a command to invoke the
+      script at build time.  */
+  void CreateLinkScript(const char* name,
+                        std::vector<std::string> const& link_commands,
+                        std::vector<std::string>& makefile_commands,
+                        std::vector<std::string>& makefile_depends);
+
+  /** Create a response file with the given set of options.  Returns
+      the relative path from the target build working directory to the
+      response file name.  */
+  std::string CreateResponseFile(const char* name,
+                                 std::string const& options,
+                                 std::vector<std::string>& makefile_depends);
+
+  /** Create list of flags for link libraries. */
+  void CreateLinkLibs(std::string& linkLibs, bool relink,
+                      bool useResponseFile,
+                      std::vector<std::string>& makefile_depends,
+                      bool useWatcomQuote);
+
+  /** Create lists of object files for linking and cleaning.  */
+  void CreateObjectLists(bool useLinkScript, bool useArchiveRules,
+                         bool useResponseFile, std::string& buildObjs,
+                         std::vector<std::string>& makefile_depends,
+                         bool useWatcomQuote);
+
+  void AddIncludeFlags(std::string& flags, const std::string& lang);
+
+  virtual void CloseFileStreams();
+  void RemoveForbiddenFlags(const char* flagVar, const std::string& linkLang,
+                            std::string& linkFlags);
+  cmTarget *Target;
+  cmGeneratorTarget* GeneratorTarget;
+  cmLocalUnixMakefileGenerator3 *LocalGenerator;
+  cmGlobalUnixMakefileGenerator3 *GlobalGenerator;
+  cmMakefile *Makefile;
+  std::string ConfigName;
+
+  enum CustomCommandDriveType { OnBuild, OnDepends, OnUtility };
+  CustomCommandDriveType CustomCommandDriver;
+
+  // the full path to the build file
+  std::string BuildFileName;
+  std::string BuildFileNameFull;
+
+  // the full path to the progress file
+  std::string ProgressFileNameFull;
+  unsigned long NumberOfProgressActions;
+  bool NoRuleMessages;
+
+  // the path to the directory the build file is in
+  std::string TargetBuildDirectory;
+  std::string TargetBuildDirectoryFull;
+
+  // the stream for the build file
+  cmGeneratedFileStream *BuildFileStream;
+
+  // the stream for the flag file
+  std::string FlagFileNameFull;
+  cmGeneratedFileStream *FlagFileStream;
+  class StringList: public std::vector<std::string> {};
+  std::map<std::string, StringList> FlagFileDepends;
+
+  // the stream for the info file
+  std::string InfoFileNameFull;
+  cmGeneratedFileStream *InfoFileStream;
+
+  // files to clean
+  std::vector<std::string> CleanFiles;
+
+  // objects used by this target
+  std::vector<std::string> Objects;
+  std::vector<std::string> ExternalObjects;
+
+  // Set of object file names that will be built in this directory.
+  std::set<std::string> ObjectFiles;
+
+  // Set of extra output files to be driven by the build.
+  std::set<std::string> ExtraFiles;
+
+  typedef std::map<std::string, std::string> MultipleOutputPairsType;
+  MultipleOutputPairsType MultipleOutputPairs;
+
+  // Target name info.
+  std::string TargetNameOut;
+  std::string TargetNameSO;
+  std::string TargetNameReal;
+  std::string TargetNameImport;
+  std::string TargetNamePDB;
+
+  // Mac OS X content info.
+  std::set<std::string> MacContentFolders;
+  cmOSXBundleGenerator* OSXBundleGenerator;
+  MacOSXContentGeneratorType* MacOSXContentGenerator;
+
+  typedef std::map<std::string, std::string> ByLanguageMap;
+  std::string GetFlags(const std::string &l);
+  ByLanguageMap FlagsByLanguage;
+  std::string GetDefines(const std::string &l);
+  ByLanguageMap DefinesByLanguage;
+
+  // Target-wide Fortran module output directory.
+  bool FortranModuleDirectoryComputed;
+  std::string FortranModuleDirectory;
+  const char* GetFortranModuleDirectory();
+
+  // Compute target-specific Fortran language flags.
+  void AddFortranFlags(std::string& flags);
+
+  // Helper to add flag for windows .def file.
+  void AddModuleDefinitionFlag(std::string& flags);
+
+  // Add language feature flags.
+  void AddFeatureFlags(std::string& flags, const std::string& lang);
+
+  // Feature query methods.
+  const char* GetFeature(const std::string& feature);
+  bool GetFeatureAsBool(const std::string& feature);
+
+  //==================================================================
+  // Convenience routines that do nothing more than forward to
+  // implementaitons
+  std::string Convert(const std::string& source,
+                      cmLocalGenerator::RelativeRoot relative,
+                      cmLocalGenerator::OutputFormat output =
+                      cmLocalGenerator::UNCHANGED,
+                      bool optional = false)
+  {
+    return this->LocalGenerator->Convert(source, relative, output, optional);
+  }
+
+};
+
+#endif