ENH: add cmExternalMakefileProjectGenerator, which should make it easier to

write generators for IDE projects, which use already existing makefiles
(current the kdevelop generator)
-first stept of the export interface, iniitial export() command
-more replacements for the FIND_XXX docs

Alex

1 files changed, 233 insertions, 0 deletions

diff --git a/Source/cmExportCommand.cxx b/Source/cmExportCommand.cxx
new file mode 100644
index 0000000..dfe5fa3
--- /dev/null
+++ b/Source/cmExportCommand.cxx
@@ -0,0 +1,233 @@
+/*=========================================================================
+
+  Program:   CMake - Cross-Platform Makefile Generator
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+  Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
+  See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
+
+     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.
+
+=========================================================================*/
+#include "cmExportCommand.h"
+#include "cmGlobalGenerator.h"
+#include "cmLocalGenerator.h"
+#include "cmGeneratedFileStream.h"
+#include "cmake.h"
+
+#include <cmsys/auto_ptr.hxx>
+
+// cmExportCommand
+bool cmExportCommand
+::InitialPass(std::vector<std::string> const& args)
+{
+  if(args.size() < 2 )
+    {
+    this->SetError("called with too few arguments");
+    return false;
+    }
+
+  std::string filename;
+  std::string prefix;
+  std::string exportName;
+  std::vector<std::string> targets;
+  bool append = false;
+  if (!this->ParseArgs(args, filename, prefix, exportName, targets, append))
+    {
+    return false;
+    }
+
+  if ( !this->Makefile->CanIWriteThisFile(filename.c_str()) )
+    {
+    std::string e = "attempted to write a file: " + filename
+      + " into a source directory.";
+    this->SetError(e.c_str());
+    cmSystemTools::SetFatalErrorOccured();
+    return false;
+    }
+
+  if ((targets.empty()) || (filename.empty()))
+    {
+    return true;
+    }
+
+  // Use copy-if-different if not appending.
+  cmsys::auto_ptr<std::ofstream> foutPtr;
+  if(append)
+    {
+    cmsys::auto_ptr<std::ofstream> ap(
+      new std::ofstream(filename.c_str(), std::ios::app));
+    foutPtr = ap;
+    }
+  else
+    {
+    cmsys::auto_ptr<cmGeneratedFileStream> ap(
+      new cmGeneratedFileStream(filename.c_str(), true));
+    ap->SetCopyIfDifferent(true);
+    foutPtr = ap;
+    }
+  std::ostream& fout = *foutPtr.get();
+
+  if (!fout)
+    {
+    cmSystemTools::Error("Error Writing ", filename.c_str());
+    cmSystemTools::ReportLastSystemError("");
+    return true;
+    }
+
+  // the following code may move into an "export generator"
+  // Compute the set of configurations.
+  std::vector<std::string> configurationTypes;
+  if(const char* types =
+     this->Makefile->GetDefinition("CMAKE_CONFIGURATION_TYPES"))
+    {
+    cmSystemTools::ExpandListArgument(types, configurationTypes);
+    }
+  if(configurationTypes.empty())
+    {
+    const char* config = this->Makefile->GetDefinition("CMAKE_BUILD_TYPE");
+    if (config!=0)
+      {
+      configurationTypes.push_back(config);
+      }
+    }
+
+  for(std::vector<std::string>::const_iterator currentTarget = targets.begin();
+      currentTarget != targets.end();
+      ++currentTarget)
+    {
+    // Look for a CMake target with the given name, which is an executable
+    // and which can be run
+    cmTarget* target = this->Makefile->GetLocalGenerator()->GetGlobalGenerator()->FindTarget(0, currentTarget->c_str(), true);
+    if ((target != 0)
+       && ((target->GetType() == cmTarget::EXECUTABLE)
+        || (target->GetType() == cmTarget::STATIC_LIBRARY)
+        || (target->GetType() == cmTarget::SHARED_LIBRARY)
+        || (target->GetType() == cmTarget::MODULE_LIBRARY)))
+      {
+      switch (target->GetType())
+        {
+        case cmTarget::EXECUTABLE:
+          fout << "ADD_EXECUTABLE(" << prefix.c_str() << currentTarget->c_str() << " IMPORT )\n";
+          break;
+        case cmTarget::STATIC_LIBRARY:
+          fout << "ADD_LIBRARY(" << prefix.c_str() << currentTarget->c_str() << " STATIC IMPORT )\n";
+          break;
+        case cmTarget::SHARED_LIBRARY:
+          fout << "ADD_LIBRARY(" << prefix.c_str() << currentTarget->c_str() << " SHARED IMPORT )\n";
+          break;
+        case cmTarget::MODULE_LIBRARY:
+          fout << "ADD_LIBRARY(" << prefix.c_str() << currentTarget->c_str() << " MODULE IMPORT )\n";
+          break;
+        default:  // should never happen
+          break;
+        }
+
+      fout << "SET_TARGET_PROPERTIES(" << prefix.c_str() << currentTarget->c_str() << " PROPERTIES \n";
+      fout << "                      LOCATION " << target->GetLocation(0) << "\n";
+      for(std::vector<std::string>::const_iterator currentConfig = configurationTypes.begin();
+          currentConfig != configurationTypes.end();
+          ++currentConfig)
+        {
+        if (!currentConfig->empty())
+          {
+          const char* loc = target->GetLocation(currentConfig->c_str());
+          if (loc && *loc)
+            {
+            fout << "                      " << currentConfig->c_str()<< "_LOCATION " << loc << "\n";
+            }
+          }
+        }
+      fout << "                     )\n\n";
+      }
+    else
+      {
+      }
+    }
+
+  return true;
+}
+
+bool cmExportCommand::ParseArgs(const std::vector<std::string>& args,
+                                std::string& filename,
+                                std::string& prefix,
+                                std::string& exportName,
+                                std::vector<std::string>& targets,
+                                bool& append) const
+{
+  bool doingFile = false;
+  bool doingPrefix = false;
+  bool doingTargets = false;
+  bool doingName = true;
+  for(std::vector<std::string>::const_iterator it = args.begin();
+      it != args.end();
+      ++it)
+    {
+    if (*it == "FILE")
+      {
+      doingFile = true;
+      doingPrefix = false;
+      doingName = false;
+      doingTargets = false;
+      }
+    else if (*it == "PREFIX")
+      {
+      doingFile = false;
+      doingPrefix = true;
+      doingName = false;
+      doingTargets = false;
+      }
+    else if (*it == "TARGETS")
+      {
+      doingFile = false;
+      doingPrefix = false;
+      doingName = false;
+      doingTargets = true;
+      }
+    else if (*it == "APPEND")
+      {
+      append = true;
+      doingFile = false;
+      doingPrefix = false;
+      doingName = false;
+      doingTargets = false;
+      }
+    else if (doingFile)
+      {
+      filename = *it;
+      doingFile = false;
+      doingPrefix = false;
+      doingName = false;
+      doingTargets = false;
+      }
+    else if (doingPrefix)
+      {
+      prefix = *it;
+      doingFile = false;
+      doingPrefix = false;
+      doingName = false;
+      doingTargets = false;
+      }
+    else if (doingTargets)
+      {
+      targets.push_back(*it);
+      }
+    else if (doingName)
+      {
+      exportName = *it;
+      doingFile = false;
+      doingPrefix = false;
+      doingName = false;
+      doingTargets = false;
+      }
+    else
+      {
+      }
+    }
+  return true;
+}