add new borland generator

Source/CMakeLists.txt

@@ -37,6 +37,7 @@ ADD_DEFINITIONS(-DCMAKE_BUILD_WITH_CMAKE)
 
 IF (WIN32)
   SOURCE_FILES(SRCS cmDSWWriter.cxx cmDSPWriter.cxx cmMSProjectGenerator.cxx)
+  SOURCE_FILES(SRCS cmBorlandMakefileGenerator2.cxx)
   SOURCE_FILES(SRCS cmBorlandMakefileGenerator.cpp)
   SOURCE_FILES(SRCS cmNMakeMakefileGenerator.cxx)
   IF(NOT UNIX)

Source/cmBorlandMakefileGenerator2.cxx

@@ -0,0 +1,452 @@
+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+Copyright (c) 2001 Insight Consortium
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * 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.
+
+=========================================================================*/
+#include "cmBorlandMakefileGenerator2.h"
+#include "cmMakefile.h"
+#include "cmStandardIncludes.h"
+#include "cmSystemTools.h"
+#include "cmSourceFile.h"
+#include "cmMakeDepend.h"
+#include "cmCacheManager.h"
+#include "cmGeneratedFileStream.h"
+#include "windows.h"
+
+
+cmBorlandMakefileGenerator2::cmBorlandMakefileGenerator2()
+{
+  this->SetLibraryPathOption("-L");
+}
+
+cmBorlandMakefileGenerator2::~cmBorlandMakefileGenerator2()
+{
+}
+
+
+void cmBorlandMakefileGenerator2::ComputeSystemInfo()
+{
+  // now load the settings
+  if(!m_Makefile->GetDefinition("CMAKE_ROOT"))
+    {
+    cmSystemTools::Error(
+      "CMAKE_ROOT has not been defined, bad GUI or driver program");
+    return;
+    }
+  std::string fpath = 
+    m_Makefile->GetDefinition("CMAKE_ROOT");
+  fpath += "/Templates/CMakeWindowsBorlandConfig2.cmake";
+  m_Makefile->ReadListFile(NULL,fpath.c_str());
+}
+
+
+  
+void cmBorlandMakefileGenerator2::OutputMakeVariables(std::ostream& fout)
+{
+  fout << "# NMake Makefile generated by cmake\n";
+  const char* variables = 
+    "# general varibles used in the makefile\n"
+    "\n"
+    "# Path to cmake\n"
+    "CMAKE_COMMAND = ${CMAKE_COMMAND}\n"    
+    "CMAKE_STANDARD_WINDOWS_LIBRARIES = @CMAKE_STANDARD_WINDOWS_LIBRARIES@\n"
+    "FLAGS_LINK_EXE    = @FLAGS_LINK_EXE@ \n"
+    "FLAGS_LINK_LIB    = @FLAGS_LINK_LIB@ \n"
+    "FLAGS_LINK_STATIC    = @FLAGS_LINK_STATIC@ \n"
+    "CMAKE_C_COMPILER    = @CMAKE_C_COMPILER@ \n"
+    "CMAKE_CFLAGS        = @CMAKE_CFLAGS@ @BUILD_FLAGS@\n"
+    "CMAKE_CXX_COMPILER  = @CMAKE_CXX_COMPILER@\n"
+    "CMAKE_CXXFLAGS      = -P @CMAKE_CXX_FLAGS@ @BUILD_FLAGS@\n";
+  std::string buildType = "CMAKE_CXX_FLAGS_";
+  buildType +=  m_Makefile->GetDefinition("CMAKE_BUILD_TYPE");
+  buildType = cmSystemTools::UpperCase(buildType);
+  m_Makefile->AddDefinition("BUILD_FLAGS",
+                            m_Makefile->GetDefinition(
+                              buildType.c_str()));
+  std::string replaceVars = variables;
+  m_Makefile->ExpandVariablesInString(replaceVars);
+  fout << replaceVars.c_str();
+  fout << "CMAKE_CURRENT_SOURCE = " 
+       << ShortPath(m_Makefile->GetStartDirectory() )
+       << "\n";
+  fout << "CMAKE_CURRENT_BINARY = " 
+       << ShortPath(m_Makefile->GetStartOutputDirectory())
+       << "\n";
+  fout << "CMAKE_SOURCE_DIR = " 
+       << ShortPath(m_Makefile->GetHomeDirectory()) << "\n";
+  fout << "CMAKE_BINARY_DIR = " 
+       << ShortPath(m_Makefile->GetHomeOutputDirectory() )
+       << "\n";
+  // Output Include paths
+  fout << "INCLUDE_FLAGS = ";
+  std::vector<std::string>& includes = m_Makefile->GetIncludeDirectories();
+  std::vector<std::string>::iterator i;
+  fout << "-I" << cmSystemTools::EscapeSpaces(m_Makefile->GetStartDirectory()) << " ";
+  for(i = includes.begin(); i != includes.end(); ++i)
+    {
+    std::string include = *i;
+    // Don't output a -I for the standard include path "/usr/include".
+    // This can cause problems with certain standard library
+    // implementations because the wrong headers may be found first.
+    if(include != "/usr/include")
+      {
+      fout << "-I" << cmSystemTools::EscapeSpaces(i->c_str()).c_str() << " ";
+      }
+    } 
+  fout << m_Makefile->GetDefineFlags();
+  fout << "\n\n";
+}
+
+
+void cmBorlandMakefileGenerator2::BuildInSubDirectory(std::ostream& fout,
+                                                  const char* directory,
+                                                  const char* target1,
+                                                  const char* target2)
+{
+  if(target1)
+    {
+    std::string dir = directory;
+    cmSystemTools::ConvertToWindowsSlashes(dir);
+    fout << "\tif not exist " << cmSystemTools::EscapeSpaces(dir.c_str())
+         << " " 
+         << "$(MAKE) rebuild_cache\n"
+         << "\tcd .\\" << directory << "\n"
+         << "\t$(MAKE) -$(MAKEFLAGS) " << target1 << "\n";
+    }
+  if(target2)
+    {
+    fout << "\t$(MAKE) -$(MAKEFLAGS) " << target2 << "\n";
+    }
+  std::string currentDir = m_Makefile->GetCurrentOutputDirectory();
+  cmSystemTools::ConvertToWindowsSlashes(currentDir);
+  fout << "\tcd " << cmSystemTools::EscapeSpaces(currentDir.c_str()) << "\n";
+}
+
+
+
+
+// This needs to be overriden because nmake requires commands to be quoted
+// if the are full paths to the executable????
+
+void cmBorlandMakefileGenerator2::OutputMakeRule(std::ostream& fout, 
+                                              const char* comment,
+                                              const char* target,
+                                              const char* depends, 
+                                              const char* command,
+                                              const char* command2,
+                                              const char* command3,
+                                              const char* command4)
+{
+  if(!target)
+    {
+    cmSystemTools::Error("no target for OutputMakeRule");
+    return;
+    }
+  
+  std::string replace;
+  if(comment)
+    {
+    replace = comment;
+    m_Makefile->ExpandVariablesInString(replace);
+    fout << "#---------------------------------------------------------\n";
+    fout << "# " << comment;
+    fout << "\n#\n";
+    }
+  fout << "\n";
+  replace = target;
+  m_Makefile->ExpandVariablesInString(replace);
+  replace = cmSystemTools::EscapeSpaces(replace.c_str());
+  fout << replace.c_str() << ": ";
+  if(depends)
+    {
+    replace = depends;
+    m_Makefile->ExpandVariablesInString(replace);
+    fout << replace.c_str();
+    }
+  fout << "\n";
+  const char* startCommand = "\t";
+  const char* endCommand = "\n";
+  if(command)
+    {
+    replace = ShortPathCommand(command);
+    m_Makefile->ExpandVariablesInString(replace);
+    fout << startCommand << replace.c_str() << endCommand;
+    }
+  if(command2)
+    {
+    replace = ShortPathCommand(command2);
+    m_Makefile->ExpandVariablesInString(replace);
+    fout << startCommand << replace.c_str() << endCommand;
+    }
+  if(command3)
+    {
+    replace = ShortPathCommand(command3);
+    m_Makefile->ExpandVariablesInString(replace);
+    fout << startCommand << replace.c_str() << endCommand;
+    }
+  if(command4)
+    {
+    replace = ShortPathCommand(command4);
+    m_Makefile->ExpandVariablesInString(replace);
+    fout << startCommand << replace.c_str() << endCommand;
+    }
+  fout << "\n";
+  // reset m_QuoteNextCommand, as the default should be to quote the 
+  // commands.   We need the quotes when the command has a full path
+  // to an executable.  However, the quotes break things like the
+  // linker command.
+  m_QuoteNextCommand = true;
+}
+
+void 
+cmBorlandMakefileGenerator2::
+OutputBuildObjectFromSource(std::ostream& fout,
+                            const char* shortName,
+                            const cmSourceFile& source,
+                            const char* extraCompileFlags,
+                            bool shared)
+{ 
+  std::string comment = "Build ";
+  std::string objectFile = std::string(shortName) + 
+    this->GetOutputExtension(source.GetSourceExtension().c_str());
+  
+  comment += objectFile + "  From ";
+  comment += source.GetFullPath();
+  std::string compileCommand;
+  std::string ext = source.GetSourceExtension();
+  if(ext == "c" )
+    {
+    compileCommand = "$(CMAKE_C_COMPILER) $(CMAKE_CFLAGS) ";
+    compileCommand += extraCompileFlags;
+    if(shared)
+      {
+      compileCommand += "$(CMAKE_SHLIB_CFLAGS) ";
+      }
+    compileCommand += "$(INCLUDE_FLAGS) -c ";
+    compileCommand += 
+      cmSystemTools::EscapeSpaces(source.GetFullPath().c_str());
+    compileCommand += " /Fo";
+    compileCommand += objectFile;
+    }
+  else if (ext == "rc")
+    {
+    compileCommand = "$(RC) /fo\"";
+    compileCommand += objectFile;
+    compileCommand += "\" ";
+    compileCommand += 
+      cmSystemTools::EscapeSpaces(source.GetFullPath().c_str());
+    }
+  else if (ext == "def")
+    {
+    // no rule to output for this one
+    return;
+    }
+  // assume c++ if not c rc or def
+  else
+    {
+    compileCommand = "$(CMAKE_CXX_COMPILER) $(CMAKE_CXXFLAGS) ";
+    compileCommand += extraCompileFlags;
+    if(shared)
+      {
+      compileCommand += "$(CMAKE_SHLIB_CFLAGS) ";
+      }
+    compileCommand += "$(INCLUDE_FLAGS) -c ";
+    compileCommand += 
+      cmSystemTools::EscapeSpaces(source.GetFullPath().c_str());
+    compileCommand += " /Fo";
+    compileCommand += objectFile;
+    }
+  m_QuoteNextCommand = false;
+  this->OutputMakeRule(fout,
+                       comment.c_str(),
+                       objectFile.c_str(),
+                       cmSystemTools::EscapeSpaces(
+                         source.GetFullPath().c_str()).c_str(),
+                       compileCommand.c_str());
+}
+
+void cmBorlandMakefileGenerator2::OutputSharedLibraryRule(std::ostream& fout, 
+                                                       const char* name,
+                                                       const cmTarget &t)
+{
+  std::string target = m_LibraryOutputPath + name + ".dll";
+  std::string depend = "$(";
+  depend += name;
+  depend += "_SRC_OBJS) $(" + std::string(name) + "_DEPEND_LIBS)";
+  std::string command = "ilink32 /dll $(FLAGS_LINK_LIB) @&&|\n";
+  command += "$(" + std::string(name) + "_SRC_OBJS) /out:";
+  std::string dllpath = m_LibraryOutputPath +  std::string(name) + ".dll ";
+  cmSystemTools::ConvertToWindowsSlashes(dllpath);
+  command += cmSystemTools::EscapeSpaces(dllpath.c_str());
+  std::strstream linklibs;
+  this->OutputLinkLibraries(linklibs, name, t);
+  linklibs << std::ends;
+  command += linklibs.str();
+  delete [] linklibs.str();
+  const std::vector<cmSourceFile>& sources = t.GetSourceFiles();
+  for(std::vector<cmSourceFile>::const_iterator i = sources.begin();
+      i != sources.end(); ++i)
+    {
+    if(i->GetSourceExtension() == "def")
+      {
+      command += "/DEF:";
+      command += i->GetFullPath();
+      }
+    }
+  command += "\n|\n";
+  m_QuoteNextCommand = false;
+  this->OutputMakeRule(fout, "rules for a shared library",
+                       target.c_str(),
+                       depend.c_str(),
+                       command.c_str());
+}
+
+void cmBorlandMakefileGenerator2::OutputModuleLibraryRule(std::ostream& fout, 
+                                                       const char* name, 
+                                                       const cmTarget &target)
+{
+  this->OutputSharedLibraryRule(fout, name, target);
+}
+
+void cmBorlandMakefileGenerator2::OutputStaticLibraryRule(std::ostream& fout, 
+                                                       const char* name,
+                                                       const cmTarget &)
+{
+  std::string target = m_LibraryOutputPath + std::string(name) + ".lib";
+  std::string depend = "$(";
+  depend += std::string(name) + "_SRC_OBJS)";
+  std::string command = "tlib $(FLAGS_LINK_STATIC)  @&&|\n\t /u ";
+  std::string deleteCommand = "del ";
+  deleteCommand += target;
+  std::string libpath = m_LibraryOutputPath + std::string(name) + ".lib";
+  cmSystemTools::ConvertToWindowsSlashes(libpath);
+  command += cmSystemTools::EscapeSpaces(libpath.c_str());
+  command += " $(";
+  command += std::string(name) + "_SRC_OBJS)";
+  command += "\n|\n";
+  std::string comment = "rule to build static library: ";
+  comment += name;
+  m_QuoteNextCommand = false;
+  this->OutputMakeRule(fout,
+                       comment.c_str(),
+                       target.c_str(),
+                       depend.c_str(),
+                       deleteCommand.c_str(),
+                       command.c_str());
+}
+
+void cmBorlandMakefileGenerator2::OutputExecutableRule(std::ostream& fout,
+                                                    const char* name,
+                                                    const cmTarget &t)
+{
+  std::string target = m_ExecutableOutputPath + name;
+  target += ".exe";
+  std::string depend = "$(";
+  depend += std::string(name) + "_SRC_OBJS) $(" + std::string(name) + "_DEPEND_LIBS)";
+  std::string command = 
+    "$(CMAKE_CXX_COMPILER) ";
+  command += "$(" + std::string(name) + "_SRC_OBJS) ";
+  std::string path = m_ExecutableOutputPath + name + ".exe";
+  command += " -e" + 
+    cmSystemTools::EscapeSpaces(path.c_str());
+  if(t.GetType() == cmTarget::WIN32_EXECUTABLE)
+    {
+    command +=  " -tWM ";
+    }
+  else
+    {
+    command += " -tWC ";
+    }
+  
+  std::strstream linklibs;
+  this->OutputLinkLibraries(linklibs, 0, t);
+  linklibs << std::ends;
+  command += linklibs.str();
+  std::string comment = "rule to build executable: ";
+  comment += name;
+  m_QuoteNextCommand = false;
+  this->OutputMakeRule(fout, 
+                       comment.c_str(),
+                       target.c_str(),
+                       depend.c_str(),
+                       command.c_str());
+}
+
+  
+
+
+std::string cmBorlandMakefileGenerator2::GetOutputExtension(const char* s)
+{
+  std::string sourceExtension = s;
+  if(sourceExtension == "def")
+    {
+    return "";
+    }
+  if(sourceExtension == "ico" || sourceExtension == "rc2")
+    {
+    return "";
+    }
+  if(sourceExtension == "rc")
+    {
+    return ".res";
+    }
+  return ".obj";
+}
+
+
+
+bool cmBorlandMakefileGenerator2::SamePath(const char* path1, const char* path2)
+{
+  // first check to see if they are the same anyway
+  if (strcmp(path1, path2) == 0)
+    {
+    return true;
+    }
+  // next short path and lower case both of them for the compare
+  return 
+    cmSystemTools::LowerCase(ShortPath(path1)) ==
+    cmSystemTools::LowerCase(ShortPath(path2));
+}
+
+void cmBorlandMakefileGenerator2::OutputBuildLibraryInDir(std::ostream& fout,
+						       const char* path,
+						       const char* s,
+						       const char* fullpath)
+{
+  cmNMakeMakefileGenerator::OutputBuildLibraryInDir(fout, path, s, fullpath);
+}

Source/cmBorlandMakefileGenerator2.h

@@ -0,0 +1,112 @@
+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+Copyright (c) 2001 Insight Consortium
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * 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.
+
+=========================================================================*/
+#ifndef cmBorlandMakefileGenerator2_h
+#define cmBorlandMakefileGenerator2_h
+
+#include "cmNMakeMakefileGenerator.h"
+
+/** \class cmBorlandMakefileGenerator2
+ * \brief Write an NMake makefile.
+ *
+ * cmBorlandMakefileGenerator2 produces a Unix makefile from its
+ * member m_Makefile.
+ */
+class cmBorlandMakefileGenerator2 : public cmNMakeMakefileGenerator
+{
+public:
+  ///! Set cache only and recurse to false by default.
+  cmBorlandMakefileGenerator2();
+
+  virtual ~cmBorlandMakefileGenerator2();
+  
+  ///! Get the name for the generator.
+  virtual const char* GetName() {return "Borland Makefiles2";}
+
+  ///! virtual copy constructor
+  virtual cmMakefileGenerator* CreateObject() 
+    { return new cmBorlandMakefileGenerator2;}
+
+  ///! figure out about the current system information
+  virtual void ComputeSystemInfo(); 
+protected:
+  virtual void OutputMakeVariables(std::ostream&);
+  virtual void BuildInSubDirectory(std::ostream& fout,
+                                   const char* directory,
+                                   const char* target1,
+                                   const char* target2);
+  void OutputMakeRule(std::ostream& fout, 
+                      const char* comment,
+                      const char* target,
+                      const char* depends, 
+                      const char* command,
+                      const char* command2=0,
+                      const char* command3=0,
+                      const char* command4=0); 
+  
+  
+  virtual void OutputBuildObjectFromSource(std::ostream& fout,
+                                           const char* shortName,
+                                           const cmSourceFile& source,
+                                           const char* extraCompileFlags,
+                                           bool sharedTarget); 
+  virtual void OutputSharedLibraryRule(std::ostream&, const char* name,
+                                       const cmTarget &);
+  virtual void OutputModuleLibraryRule(std::ostream&, const char* name, 
+                                       const cmTarget &);
+  virtual void OutputStaticLibraryRule(std::ostream&, const char* name,
+                                       const cmTarget &);
+  virtual void OutputExecutableRule(std::ostream&, const char* name,
+                                    const cmTarget &);
+  virtual std::string GetOutputExtension(const char* sourceExtension); 
+  virtual void OutputBuildLibraryInDir(std::ostream& fout,
+				       const char* path,
+				       const char* library,
+				       const char* fullpath); 
+  ///! return true if the two paths are the same (checks short paths)
+  virtual bool SamePath(const char* path1, const char* path2);
+private:
+  bool m_QuoteNextCommand;      // if this is true, OutputMakeRule
+                                // will not quote the next commands
+                                // it is reset to false after each
+                                // call to OutputMakeRule
+};
+
+#endif

Source/cmNMakeMakefileGenerator.cxx

@@ -48,9 +48,25 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "cmGeneratedFileStream.h"
 #include "windows.h"
 
+
+cmNMakeMakefileGenerator::cmNMakeMakefileGenerator()
+{
+  m_LibraryPathOption = "-LIBPATH:";
+  this->SetObjectFileExtension(".obj");
+  this->SetExecutableExtension(".exe");
+  this->SetLibraryPrefix("");
+  this->SetSharedLibraryExtension(".dll");
+  this->SetStaticLibraryExtension(".lib");
+  m_QuoteNextCommand = true; // most of the time command should be quoted
+}
+
+cmNMakeMakefileGenerator::~cmNMakeMakefileGenerator()
+{
+}
+
 // convert to windows short paths if there are spaces
 // in path
-inline std::string ShortPath(const char* path)
+std::string cmNMakeMakefileGenerator::ShortPath(const char* path)
 {
   std::string ret = path;
   // if there are no spaces in path, then just return path
@@ -80,7 +96,7 @@ inline std::string ShortPath(const char* path)
 // convert a command to a short path if it has spaces
 // this separates the arguments from the command and puts
 // them back together
-inline std::string ShortPathCommand(const char* command)
+std::string cmNMakeMakefileGenerator::ShortPathCommand(const char* command)
 {
   if(!strchr(command, ' '))
     {
@@ -105,21 +121,6 @@ inline std::string ShortPathCommand(const char* command)
 }
 
 
-cmNMakeMakefileGenerator::cmNMakeMakefileGenerator()
-{
-  this->SetObjectFileExtension(".obj");
-  this->SetExecutableExtension(".exe");
-  this->SetLibraryPrefix("");
-  this->SetSharedLibraryExtension(".dll");
-  this->SetStaticLibraryExtension(".lib");
-  m_QuoteNextCommand = true; // most of the time command should be quoted
-}
-
-cmNMakeMakefileGenerator::~cmNMakeMakefileGenerator()
-{
-}
-
-
 void cmNMakeMakefileGenerator::ComputeSystemInfo()
 {
   // now load the settings
@@ -480,7 +481,7 @@ void cmNMakeMakefileGenerator::OutputLinkLibraries(std::ostream& fout,
     std::string libpath = ShortPath(libDir->c_str());
     if(emitted.insert(libpath).second)
       {
-      linkLibs += "-LIBPATH:";
+      linkLibs += m_LibraryPathOption;
       linkLibs += libpath;
       linkLibs += " ";
       }

Source/cmNMakeMakefileGenerator.h

@@ -67,6 +67,8 @@ public:
   ///! figure out about the current system information
   virtual void ComputeSystemInfo(); 
 protected:
+  std::string ShortPath(const char* path);
+  std::string ShortPathCommand(const char* command);
   virtual void OutputMakeVariables(std::ostream&);
   virtual void BuildInSubDirectory(std::ostream& fout,
                                    const char* directory,
@@ -106,11 +108,13 @@ protected:
 				       const char* fullpath); 
   ///! return true if the two paths are the same (checks short paths)
   virtual bool SamePath(const char* path1, const char* path2);
+  void SetLibraryPathOption(const char* lib){ m_LibraryPathOption = lib;}
 private:
   bool m_QuoteNextCommand;      // if this is true, OutputMakeRule
                                 // will not quote the next commands
                                 // it is reset to false after each
                                 // call to OutputMakeRule
+  std::string m_LibraryPathOption;
 };
 
 #endif

Source/cmake.cxx

@@ -45,6 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #if defined(_WIN32) && !defined(__CYGWIN__)
 #include "cmMSProjectGenerator.h"
 #include "cmBorlandMakefileGenerator.h"
+#include "cmBorlandMakefileGenerator2.h"
 #include "cmNMakeMakefileGenerator.h"
 #else
 #include "cmUnixMakefileGenerator.h"
@@ -57,6 +58,7 @@ cmake::cmake()
   cmMakefileGenerator::RegisterGenerator(new cmMSProjectGenerator);
   cmMakefileGenerator::RegisterGenerator(new cmNMakeMakefileGenerator);
   cmMakefileGenerator::RegisterGenerator(new cmBorlandMakefileGenerator);
+  cmMakefileGenerator::RegisterGenerator(new cmBorlandMakefileGenerator2);
 #else
   cmMakefileGenerator::RegisterGenerator(new cmUnixMakefileGenerator);
 #endif