summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorKen Martin <ken.martin@kitware.com>2002-09-04 19:22:11 (GMT)
committerKen Martin <ken.martin@kitware.com>2002-09-04 19:22:11 (GMT)
commitd28e483f4e40ed39c4462ac2423e064f84a8b37d (patch)
treece80d60efdbaec0edb6a74e5212f7c152464d817
parentb8e39b0a61ce9dc85b9a645005e6886d87b6baf4 (diff)
downloadCMake-d28e483f4e40ed39c4462ac2423e064f84a8b37d.zip
CMake-d28e483f4e40ed39c4462ac2423e064f84a8b37d.tar.gz
CMake-d28e483f4e40ed39c4462ac2423e064f84a8b37d.tar.bz2
first cut a new arch
-rw-r--r--Source/cmGlobalBorlandMakefileGenerator.cxx56
-rw-r--r--Source/cmGlobalBorlandMakefileGenerator.h45
-rw-r--r--Source/cmLocalBorlandMakefileGenerator.cxx432
-rw-r--r--Source/cmLocalBorlandMakefileGenerator.h60
4 files changed, 593 insertions, 0 deletions
diff --git a/Source/cmGlobalBorlandMakefileGenerator.cxx b/Source/cmGlobalBorlandMakefileGenerator.cxx
new file mode 100644
index 0000000..81668a5
--- /dev/null
+++ b/Source/cmGlobalBorlandMakefileGenerator.cxx
@@ -0,0 +1,56 @@
+/*=========================================================================
+
+ Program: Insight Segmentation & Registration Toolkit
+ Module: $RCSfile$
+ Language: C++
+ Date: $Date$
+ Version: $Revision$
+
+ Copyright (c) 2002 Insight Consortium. All rights reserved.
+ See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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 "cmGlobalBorlandMakefileGenerator.h"
+#include "cmLocalBorlandMakefileGenerator.h"
+#include "cmMakefile.h"
+#include "cmake.h"
+
+void cmGlobalBorlandMakefileGenerator::EnableLanguage(const char* lang,
+ cmMakefile *mf)
+{
+ // now load the settings
+ if(!mf->GetDefinition("CMAKE_ROOT"))
+ {
+ cmSystemTools::Error(
+ "CMAKE_ROOT has not been defined, bad GUI or driver program");
+ return;
+ }
+ std::string outdir = m_CMakeInstance->GetStartOutputDirectory();
+ if(outdir.find('-') != std::string::npos)
+ {
+ std::string message = "The Borland command line tools do not support path names that have - in them. Please re-name your output directory and use _ instead of -.";
+ message += "\nYour path currently is: ";
+ message += outdir;
+ cmSystemTools::Error(message.c_str());
+ }
+ if(!this->GetLanguageEnabled("CXX"))
+ {
+ std::string fpath =
+ mf->GetDefinition("CMAKE_ROOT");
+ fpath += "/Templates/CMakeBorlandWindowsSystemConfig.cmake";
+ mf->ReadListFile(NULL,fpath.c_str());
+ this->SetLanguageEnabled("CXX");
+ }
+}
+
+///! Create a local generator appropriate to this Global Generator
+cmLocalGenerator *cmGlobalBorlandMakefileGenerator::CreateLocalGenerator()
+{
+ cmLocalGenerator *lg = new cmLocalBorlandMakefileGenerator;
+ lg->SetGlobalGenerator(this);
+ return lg;
+}
diff --git a/Source/cmGlobalBorlandMakefileGenerator.h b/Source/cmGlobalBorlandMakefileGenerator.h
new file mode 100644
index 0000000..cfc3465
--- /dev/null
+++ b/Source/cmGlobalBorlandMakefileGenerator.h
@@ -0,0 +1,45 @@
+/*=========================================================================
+
+ Program: Insight Segmentation & Registration Toolkit
+ Module: $RCSfile$
+ Language: C++
+ Date: $Date$
+ Version: $Revision$
+
+ Copyright (c) 2002 Insight Consortium. All rights reserved.
+ See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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.
+
+=========================================================================*/
+#ifndef cmGlobalBorlandMakefileGenerator_h
+#define cmGlobalBorlandMakefileGenerator_h
+
+#include "cmGlobalNMakeMakefileGenerator.h"
+
+/** \class cmGlobalBorlandMakefileGenerator
+ * \brief Write a Borland makefiles.
+ *
+ * cmGlobalBorlandMakefileGenerator manages nmake build process for a tree
+ */
+class cmGlobalBorlandMakefileGenerator : public cmGlobalNMakeMakefileGenerator
+{
+public:
+ ///! Get the name for the generator.
+ virtual const char* GetName() {
+ return cmGlobalBorlandMakefileGenerator::GetActualName();}
+ static const char* GetActualName() {return "Borland Makefiles";}
+
+ ///! Create a local generator appropriate to this Global Generator
+ virtual cmLocalGenerator *CreateLocalGenerator();
+
+ /**
+ * Try to determine system infomation such as shared library
+ * extension, pthreads, byte order etc.
+ */
+ virtual void EnableLanguage(const char*,cmMakefile *mf);
+};
+
+#endif
diff --git a/Source/cmLocalBorlandMakefileGenerator.cxx b/Source/cmLocalBorlandMakefileGenerator.cxx
new file mode 100644
index 0000000..872fc90
--- /dev/null
+++ b/Source/cmLocalBorlandMakefileGenerator.cxx
@@ -0,0 +1,432 @@
+/*=========================================================================
+
+ Program: Insight Segmentation & Registration Toolkit
+ Module: $RCSfile$
+ Language: C++
+ Date: $Date$
+ Version: $Revision$
+
+ Copyright (c) 2002 Insight Consortium. All rights reserved.
+ See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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 "cmLocalBorlandMakefileGenerator.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"
+
+
+cmLocalBorlandMakefileGenerator::cmLocalBorlandMakefileGenerator()
+{
+ this->SetLibraryPathOption("-L");
+ this->SetLibraryLinkOption("");
+}
+
+cmLocalBorlandMakefileGenerator::~cmLocalBorlandMakefileGenerator()
+{
+}
+
+
+void cmLocalBorlandMakefileGenerator::OutputMakeVariables(std::ostream& fout)
+{
+ fout << "# NMake Makefile generated by cmake\n";
+ const char* variables =
+ "# general varibles used in the makefile\n"
+ "\n"
+ "CMAKE_STANDARD_WINDOWS_LIBRARIES = @CMAKE_STANDARD_WINDOWS_LIBRARIES@\n"
+ "CMAKE_C_FLAGS = @CMAKE_C_FLAGS@ @BUILD_FLAGS@\n"
+ "CMAKE_OBJECT_FILE_SUFFIX = @CMAKE_OBJECT_FILE_SUFFIX@\n"
+ "CMAKE_EXECUTABLE_SUFFIX = @CMAKE_EXECUTABLE_SUFFIX@\n"
+ "CMAKE_STATICLIB_SUFFIX = @CMAKE_STATICLIB_SUFFIX@\n"
+ "CMAKE_SHLIB_SUFFIX = @CMAKE_SHLIB_SUFFIX@\n"
+ "CMAKE_SHLIB_CFLAGS = -tWR\n"
+ "CMAKE_LINKER_FLAGS = @CMAKE_LINKER_FLAGS@ @LINKER_BUILD_FLAGS@\n"
+ "CMAKE_CXX_FLAGS = -P @CMAKE_CXX_FLAGS@ @BUILD_FLAGS@\n"
+ "!IF \"$(OS)\" == \"Windows_NT\"\n"
+ "NULL=\n"
+ "!ELSE \n"
+ "NULL=nul\n"
+ "!ENDIF \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()));
+
+ buildType = "CMAKE_LINKER_FLAGS_";
+ buildType += m_Makefile->GetDefinition("CMAKE_BUILD_TYPE");
+ buildType = cmSystemTools::UpperCase(buildType);
+ m_Makefile->AddDefinition("LINKER_BUILD_FLAGS",
+ m_Makefile->GetDefinition(
+ buildType.c_str()));
+
+ std::string replaceVars = variables;
+ m_Makefile->ExpandVariablesInString(replaceVars);
+ std::string ccompiler = m_Makefile->GetDefinition("CMAKE_C_COMPILER");
+ fout << "CMAKE_C_COMPILER = "
+ << cmSystemTools::ConvertToOutputPath(ccompiler.c_str())
+ << "\n";
+ std::string cxxcompiler = m_Makefile->GetDefinition("CMAKE_CXX_COMPILER");
+ fout << "CMAKE_CXX_COMPILER = "
+ << cmSystemTools::ConvertToOutputPath(cxxcompiler.c_str())
+ << "\n";
+
+ if(m_Makefile->GetDefinition("CMAKE_EDIT_COMMAND"))
+ {
+ fout << "CMAKE_EDIT_COMMAND = "
+ << this->ShortPath(m_Makefile->GetDefinition("CMAKE_EDIT_COMMAND"))
+ << "\n";
+ }
+
+ std::string cmakecommand = m_Makefile->GetDefinition("CMAKE_COMMAND");
+ fout << "CMAKE_COMMAND = "
+ << this->ShortPath(cmakecommand.c_str()) << "\n";
+ fout << "RM = " << this->ShortPath(cmakecommand.c_str()) << " -E remove -f\n";
+
+ 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" <<
+ this->ShortPath(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.
+ fout << "-I" << cmSystemTools::ConvertToOutputPath(i->c_str()).c_str() << " ";
+ }
+ fout << m_Makefile->GetDefineFlags();
+ fout << "\n\n";
+}
+
+
+
+void
+cmLocalBorlandMakefileGenerator::
+OutputBuildObjectFromSource(std::ostream& fout,
+ const char* shortName,
+ const cmSourceFile& source,
+ const char* extraCompileFlags,
+ bool shared)
+{
+ // force shared flag if building shared libraries
+ if(cmSystemTools::IsOn(m_Makefile->GetDefinition("BUILD_SHARED_LIBS")))
+ {
+ shared = true;
+ }
+ // Header files shouldn't have build rules.
+ if(source.GetPropertyAsBool("HEADER_FILE_ONLY"))
+ {
+ return;
+ }
+
+
+
+ std::string comment = "Build ";
+ std::string objectFile = std::string(shortName) +
+ this->GetOutputExtension(source.GetSourceExtension().c_str());
+ objectFile = cmSystemTools::ConvertToOutputPath(objectFile.c_str());
+ comment += objectFile + " From ";
+ comment += source.GetFullPath();
+ std::string compileCommand;
+ std::string ext = source.GetSourceExtension();
+ if(ext == "c" )
+ {
+ compileCommand = "$(CMAKE_C_COMPILER) $(CMAKE_C_FLAGS) ";
+ compileCommand += extraCompileFlags;
+ if(shared)
+ {
+ compileCommand += "$(CMAKE_SHLIB_CFLAGS) ";
+ }
+ compileCommand += " -o";
+ compileCommand += objectFile;
+ compileCommand += " $(INCLUDE_FLAGS) -c ";
+ compileCommand +=
+ cmSystemTools::ConvertToOutputPath(source.GetFullPath().c_str());
+ }
+ else if (ext == "rc")
+ {
+ compileCommand = "$(RC) $(INCLUDE_FLAGS) -o\"";
+ compileCommand += objectFile;
+ compileCommand += "\" ";
+ compileCommand +=
+ cmSystemTools::ConvertToOutputPath(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_CXX_FLAGS) ";
+ compileCommand += extraCompileFlags;
+ if(shared)
+ {
+ compileCommand += "$(CMAKE_SHLIB_CFLAGS) ";
+ }
+ compileCommand += " -o";
+ compileCommand += objectFile;
+ compileCommand += " $(INCLUDE_FLAGS) -c ";
+ compileCommand +=
+ cmSystemTools::ConvertToOutputPath(source.GetFullPath().c_str());
+ }
+ this->OutputMakeRule(fout,
+ comment.c_str(),
+ objectFile.c_str(),
+ cmSystemTools::ConvertToOutputPath(
+ source.GetFullPath().c_str()).c_str(),
+ compileCommand.c_str());
+}
+
+void cmLocalBorlandMakefileGenerator::OutputSharedLibraryRule(std::ostream& fout,
+ const char* name,
+ const cmTarget &t)
+{
+ std::string target = m_LibraryOutputPath + name;
+ std::string libpath = target + ".lib";
+ target += ".dll";
+ target = cmSystemTools::ConvertToOutputPath(target.c_str());
+ libpath = cmSystemTools::ConvertToOutputPath(libpath.c_str());
+ std::string depend = "$(";
+ depend += this->CreateMakeVariable(name, "_SRC_OBJS");
+ depend += ") $(" + this->CreateMakeVariable(name, "_DEPEND_LIBS") + ")";
+ std::string command = "$(CMAKE_CXX_COMPILER) -tWD $(CMAKE_SHLIB_CFLAGS) $(CMAKE_LINKER_FLAGS) @&&|\n";
+ // must be executable name
+ command += "-e";
+ command += target;
+ command += " ";
+ cmStringStream linklibs;
+ this->OutputLinkLibraries(linklibs, name, t);
+ // then the linker options -L and libraries (any other order will fail!)
+ command += linklibs.str();
+ // then list of object files
+ command += " $(" + this->CreateMakeVariable(name, "_SRC_OBJS") + ") ";
+ std::string command2 = "implib -w ";
+ command2 += libpath + " " + target;
+ 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 += "";
+ command += (*i)->GetFullPath();
+ }
+ }
+ command += "\n|\n";
+
+ std::string customCommands = this->CreateTargetRules(t, name);
+ const char* cc = 0;
+ if(customCommands.size() > 0)
+ {
+ cc = customCommands.c_str();
+ }
+ this->OutputMakeRule(fout, "rules for a shared library",
+ target.c_str(),
+ depend.c_str(),
+ command.c_str(),
+ command2.c_str(),
+ cc);
+}
+
+void cmLocalBorlandMakefileGenerator::OutputModuleLibraryRule(std::ostream& fout,
+ const char* name,
+ const cmTarget &target)
+{
+ this->OutputSharedLibraryRule(fout, name, target);
+}
+
+void cmLocalBorlandMakefileGenerator::OutputStaticLibraryRule(std::ostream& fout,
+ const char* name,
+ const cmTarget &t)
+{
+ std::string target = m_LibraryOutputPath + std::string(name) + ".lib";
+ target = cmSystemTools::ConvertToOutputPath(target.c_str());
+ std::string depend = "$(";
+ depend += this->CreateMakeVariable(name, "_SRC_OBJS") + ") ";
+ std::string command = "tlib @&&|\n\t /p512 /a ";
+ command += target;
+ command += " ";
+ std::string deleteCommand = "if exist ";
+ deleteCommand += target;
+ deleteCommand += " del ";
+ deleteCommand += target;
+
+ command += " $(";
+ command += this->CreateMakeVariable(name, "_SRC_OBJS_QUOTED") + ")";
+ command += "\n|\n";
+ std::string comment = "rule to build static library: ";
+ comment += name;
+ std::string customCommands = this->CreateTargetRules(t, name);
+ const char* cc = 0;
+ if(customCommands.size() > 0)
+ {
+ cc = customCommands.c_str();
+ }
+ this->OutputMakeRule(fout,
+ comment.c_str(),
+ target.c_str(),
+ depend.c_str(),
+ deleteCommand.c_str(),
+ command.c_str(), cc);
+}
+
+void cmLocalBorlandMakefileGenerator::OutputExecutableRule(std::ostream& fout,
+ const char* name,
+ const cmTarget &t)
+{
+ std::string target = m_ExecutableOutputPath + name + m_ExecutableExtension;
+ target = cmSystemTools::ConvertToOutputPath(target.c_str());
+ std::string depend = "$(";
+ depend += this->CreateMakeVariable(name, "_SRC_OBJS") + ") $(" +
+ this->CreateMakeVariable(name, "_DEPEND_LIBS") + ")";
+ std::string command =
+ "$(CMAKE_CXX_COMPILER) ";
+ command += " $(CMAKE_LINKER_FLAGS) -e" + target;
+ if(cmSystemTools::IsOn(m_Makefile->GetDefinition("BUILD_SHARED_LIBS")))
+ {
+ command += " $(CMAKE_SHLIB_CFLAGS) ";
+ }
+ if(t.GetType() == cmTarget::WIN32_EXECUTABLE)
+ {
+ command += " -tWM ";
+ }
+ else
+ {
+ command += " -tWC ";
+ }
+ cmStringStream linklibs;
+ this->OutputLinkLibraries(linklibs, 0, t);
+ command += linklibs.str();
+ command += " $(" + this->CreateMakeVariable(name, "_SRC_OBJS") + ")";
+
+ std::string comment = "rule to build executable: ";
+ comment += name;
+ std::string customCommands = this->CreateTargetRules(t, name);
+ const char* cc = 0;
+ if(customCommands.size() > 0)
+ {
+ cc = customCommands.c_str();
+ }
+ this->OutputMakeRule(fout,
+ comment.c_str(),
+ target.c_str(),
+ depend.c_str(),
+ command.c_str(), cc);
+}
+
+
+
+
+std::string cmLocalBorlandMakefileGenerator::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 cmLocalBorlandMakefileGenerator::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));
+}
+
+
+// borland make does not support variables that are longer than 32
+// so use this function to rename any long ones
+std::string cmLocalBorlandMakefileGenerator::CreateMakeVariable(const char* s, const char* s2)
+{
+ std::string unmodified = s;
+ unmodified += s2;
+ // see if th
+ std::map<cmStdString, cmStdString>::iterator i = m_MakeVariableMap.find(unmodified);
+ if(i != m_MakeVariableMap.end())
+ {
+ return i->second;
+ }
+ std::string ret = unmodified;
+ // if the string is greater the 32 chars it is an invalid vairable name
+ // for borland make
+ if(ret.size() > 32)
+ {
+ std::string str1 = s;
+ std::string str2 = s2;
+ // we must shorten the combined string by 4 charactors
+ // keep no more than 24 charactors from the second string
+ if(str2.size() > 24)
+ {
+ str2 = str2.substr(0, 24);
+ }
+ if(str1.size() + str2.size() > 27)
+ {
+ str1 = str1.substr(0, 27 - str2.size());
+ }
+ char buffer[5];
+ int i = 0;
+ sprintf(buffer, "%04d", i);
+ ret = str1 + str2 + buffer;
+ while(m_ShortMakeVariableMap.count(ret) && i < 1000)
+ {
+ ++i;
+ sprintf(buffer, "%04d", i);
+ ret = str1 + str2 + buffer;
+ }
+ if(i == 1000)
+ {
+ cmSystemTools::Error("Borland makefile varible length too long");
+ return unmodified;
+ }
+ // once an unused variable is found
+ m_ShortMakeVariableMap[ret] = "1";
+ }
+ // always make an entry into the unmodified to varible map
+ m_MakeVariableMap[unmodified] = ret;
+ return ret;
+}
+
diff --git a/Source/cmLocalBorlandMakefileGenerator.h b/Source/cmLocalBorlandMakefileGenerator.h
new file mode 100644
index 0000000..9855ee6
--- /dev/null
+++ b/Source/cmLocalBorlandMakefileGenerator.h
@@ -0,0 +1,60 @@
+/*=========================================================================
+
+ Program: Insight Segmentation & Registration Toolkit
+ Module: $RCSfile$
+ Language: C++
+ Date: $Date$
+ Version: $Revision$
+
+ Copyright (c) 2002 Insight Consortium. All rights reserved.
+ See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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.
+
+=========================================================================*/
+#ifndef cmBorlandMakefileGenerator_h
+#define cmBorlandMakefileGenerator_h
+
+#include "cmLocalNMakeMakefileGenerator.h"
+
+/** \class cmLocalBorlandMakefileGenerator
+ * \brief Write an Borland makefile.
+ *
+ * cmLocalBorlandMakefileGenerator produces a Unix makefile from its
+ * member m_Makefile.
+ */
+class cmLocalBorlandMakefileGenerator : public cmLocalNMakeMakefileGenerator
+{
+public:
+ ///! Set cache only and recurse to false by default.
+ cmLocalBorlandMakefileGenerator();
+
+ virtual ~cmLocalBorlandMakefileGenerator();
+
+protected:
+ virtual void OutputMakeVariables(std::ostream&);
+
+ 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);
+ ///! return true if the two paths are the same (checks short paths)
+ virtual bool SamePath(const char* path1, const char* path2);
+ virtual std::string CreateMakeVariable(const char* s, const char* s2);
+ std::map<cmStdString, cmStdString> m_MakeVariableMap;
+ std::map<cmStdString, cmStdString> m_ShortMakeVariableMap;
+};
+
+#endif