CMake/Source/cmBorlandMakefileGenerator.cxx

468 lines
15 KiB
C++
Raw Normal View History

2001-11-28 19:12:15 +03:00
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile$
Language: C++
Date: $Date$
Version: $Revision$
2002-01-21 23:30:43 +03:00
Copyright (c) 2002 Insight Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
2001-11-28 19:12:15 +03:00
2002-01-21 23:30:43 +03:00
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.
2001-11-28 19:12:15 +03:00
=========================================================================*/
2001-12-01 00:48:52 +03:00
#include "cmBorlandMakefileGenerator.h"
2001-11-28 19:12:15 +03:00
#include "cmMakefile.h"
#include "cmStandardIncludes.h"
#include "cmSystemTools.h"
#include "cmSourceFile.h"
#include "cmMakeDepend.h"
#include "cmCacheManager.h"
#include "cmGeneratedFileStream.h"
#include "windows.h"
#include <stdio.h>
2001-11-28 19:12:15 +03:00
2001-12-01 00:48:52 +03:00
cmBorlandMakefileGenerator::cmBorlandMakefileGenerator()
2001-11-28 19:12:15 +03:00
{
this->SetLibraryPathOption("-L");
this->SetLibraryLinkOption("");
2001-11-28 19:12:15 +03:00
}
2001-12-01 00:48:52 +03:00
cmBorlandMakefileGenerator::~cmBorlandMakefileGenerator()
2001-11-28 19:12:15 +03:00
{
}
void cmBorlandMakefileGenerator::EnableLanguage(const char*)
2001-11-28 19:12:15 +03:00
{
// now load the settings
if(!m_Makefile->GetDefinition("CMAKE_ROOT"))
{
cmSystemTools::Error(
"CMAKE_ROOT has not been defined, bad GUI or driver program");
return;
}
2001-12-07 18:58:06 +03:00
std::string outdir = m_Makefile->GetCurrentOutputDirectory();
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 =
m_Makefile->GetDefinition("CMAKE_ROOT");
fpath += "/Templates/CMakeBorlandWindowsSystemConfig.cmake";
m_Makefile->ReadListFile(NULL,fpath.c_str());
this->SetLanguageEnabled("CXX");
}
2001-12-07 18:58:06 +03:00
2001-11-28 19:12:15 +03:00
}
2001-12-01 00:48:52 +03:00
void cmBorlandMakefileGenerator::OutputMakeVariables(std::ostream& fout)
2001-11-28 19:12:15 +03:00
{
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"
2001-12-04 01:01:40 +03:00
"CMAKE_SHLIB_SUFFIX = @CMAKE_SHLIB_SUFFIX@\n"
"CMAKE_SHLIB_CFLAGS = -tWR\n"
2001-12-04 01:01:40 +03:00
"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"
2002-03-26 20:38:52 +03:00
"!ENDIF \n";
2001-11-28 19:12:15 +03:00
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()));
2001-12-04 01:01:40 +03:00
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()));
2001-11-28 19:12:15 +03:00
std::string replaceVars = variables;
m_Makefile->ExpandVariablesInString(replaceVars);
2002-03-26 20:38:52 +03:00
std::string ccommand = m_Makefile->GetDefinition("CCOMMAND_COMMAND");
fout << "RM = " << this->ConvertToOutputPath(ccommand.c_str()) << " remove -f\n";
std::string ccompiler = m_Makefile->GetDefinition("CMAKE_C_COMPILER");
fout << "CMAKE_C_COMPILER = "
2002-05-08 16:46:55 +04:00
<< this->ConvertToOutputPath(ccompiler.c_str())
<< "\n";
std::string cxxcompiler = m_Makefile->GetDefinition("CMAKE_CXX_COMPILER");
fout << "CMAKE_CXX_COMPILER = "
2002-05-08 16:46:55 +04:00
<< this->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";
2001-11-28 19:12:15 +03:00
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()) << " ";
2001-11-28 19:12:15 +03:00
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" << this->ConvertToOutputPath(i->c_str()).c_str() << " ";
2001-11-28 19:12:15 +03:00
}
fout << m_Makefile->GetDefineFlags();
fout << "\n\n";
}
void
2001-12-01 00:48:52 +03:00
cmBorlandMakefileGenerator::
2001-11-28 19:12:15 +03:00
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.IsAHeaderFileOnly())
{
return;
}
2001-11-28 19:12:15 +03:00
std::string comment = "Build ";
std::string objectFile = std::string(shortName) +
this->GetOutputExtension(source.GetSourceExtension().c_str());
objectFile = this->ConvertToOutputPath(objectFile.c_str());
2001-11-28 19:12:15 +03:00
comment += objectFile + " From ";
comment += source.GetFullPath();
std::string compileCommand;
std::string ext = source.GetSourceExtension();
if(ext == "c" )
{
compileCommand = "$(CMAKE_C_COMPILER) $(CMAKE_C_FLAGS) ";
2001-11-28 19:12:15 +03:00
compileCommand += extraCompileFlags;
if(shared)
{
compileCommand += "$(CMAKE_SHLIB_CFLAGS) ";
}
compileCommand += " -o";
compileCommand += objectFile;
compileCommand += " $(INCLUDE_FLAGS) -c ";
2001-11-28 19:12:15 +03:00
compileCommand +=
this->ConvertToOutputPath(source.GetFullPath().c_str());
2001-11-28 19:12:15 +03:00
}
else if (ext == "rc")
{
compileCommand = "$(RC) -o\"";
2001-11-28 19:12:15 +03:00
compileCommand += objectFile;
compileCommand += "\" ";
compileCommand +=
this->ConvertToOutputPath(source.GetFullPath().c_str());
2001-11-28 19:12:15 +03:00
}
else if (ext == "def")
{
// no rule to output for this one
return;
}
// assume c++ if not c rc or def
else
{
2001-12-01 00:05:55 +03:00
compileCommand = "$(CMAKE_CXX_COMPILER) $(CMAKE_CXX_FLAGS) ";
2001-11-28 19:12:15 +03:00
compileCommand += extraCompileFlags;
if(shared)
{
compileCommand += "$(CMAKE_SHLIB_CFLAGS) ";
}
compileCommand += " -o";
compileCommand += objectFile;
compileCommand += " $(INCLUDE_FLAGS) -c ";
2001-11-28 19:12:15 +03:00
compileCommand +=
this->ConvertToOutputPath(source.GetFullPath().c_str());
2001-11-28 19:12:15 +03:00
}
this->OutputMakeRule(fout,
comment.c_str(),
objectFile.c_str(),
this->ConvertToOutputPath(
2001-11-28 19:12:15 +03:00
source.GetFullPath().c_str()).c_str(),
compileCommand.c_str());
}
2001-12-01 00:48:52 +03:00
void cmBorlandMakefileGenerator::OutputSharedLibraryRule(std::ostream& fout,
2001-11-28 19:12:15 +03:00
const char* name,
const cmTarget &t)
{
std::string target = m_LibraryOutputPath + name;
std::string libpath = target + ".lib";
target += ".dll";
target = this->ConvertToOutputPath(target.c_str());
libpath = this->ConvertToOutputPath(libpath.c_str());
2001-11-28 19:12:15 +03:00
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 += " ";
2001-11-28 19:12:15 +03:00
std::strstream linklibs;
this->OutputLinkLibraries(linklibs, name, t);
linklibs << std::ends;
// then the linker options -L and libraries (any other order will fail!)
2001-11-28 19:12:15 +03:00
command += linklibs.str();
delete [] 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();
2001-11-28 19:12:15 +03:00
i != sources.end(); ++i)
{
if((*i)->GetSourceExtension() == "def")
2001-11-28 19:12:15 +03:00
{
command += "";
command += (*i)->GetFullPath();
2001-11-28 19:12:15 +03:00
}
}
command += "\n|\n";
2001-12-07 18:58:06 +03:00
std::string customCommands = this->CreateTargetRules(t, name);
const char* cc = 0;
if(customCommands.size() > 0)
{
cc = customCommands.c_str();
}
2001-11-28 19:12:15 +03:00
this->OutputMakeRule(fout, "rules for a shared library",
target.c_str(),
depend.c_str(),
command.c_str(),
2001-12-07 18:58:06 +03:00
command2.c_str(),
cc);
2001-11-28 19:12:15 +03:00
}
2001-12-01 00:48:52 +03:00
void cmBorlandMakefileGenerator::OutputModuleLibraryRule(std::ostream& fout,
2001-11-28 19:12:15 +03:00
const char* name,
const cmTarget &target)
{
this->OutputSharedLibraryRule(fout, name, target);
}
2001-12-01 00:48:52 +03:00
void cmBorlandMakefileGenerator::OutputStaticLibraryRule(std::ostream& fout,
2001-11-28 19:12:15 +03:00
const char* name,
2001-12-07 18:58:06 +03:00
const cmTarget &t)
2001-11-28 19:12:15 +03:00
{
std::string target = m_LibraryOutputPath + std::string(name) + ".lib";
target = this->ConvertToOutputPath(target.c_str());
2001-11-28 19:12:15 +03:00
std::string depend = "$(";
depend += this->CreateMakeVariable(name, "_SRC_OBJS") + ") ";
2002-01-09 01:18:51 +03:00
std::string command = "tlib @&&|\n\t /p512 /a ";
command += target;
command += " ";
std::string deleteCommand = "if exist ";
deleteCommand += target;
deleteCommand += " del ";
deleteCommand += target;
2001-11-28 19:12:15 +03:00
command += " $(";
command += this->CreateMakeVariable(name, "_SRC_OBJS_QUOTED") + ")";
2001-11-28 19:12:15 +03:00
command += "\n|\n";
std::string comment = "rule to build static library: ";
comment += name;
2001-12-07 18:58:06 +03:00
std::string customCommands = this->CreateTargetRules(t, name);
const char* cc = 0;
if(customCommands.size() > 0)
{
cc = customCommands.c_str();
}
2001-11-28 19:12:15 +03:00
this->OutputMakeRule(fout,
comment.c_str(),
target.c_str(),
depend.c_str(),
deleteCommand.c_str(),
2001-12-07 18:58:06 +03:00
command.c_str(), cc);
2001-11-28 19:12:15 +03:00
}
2001-12-01 00:48:52 +03:00
void cmBorlandMakefileGenerator::OutputExecutableRule(std::ostream& fout,
2001-11-28 19:12:15 +03:00
const char* name,
const cmTarget &t)
{
std::string target = m_ExecutableOutputPath + name + m_ExecutableExtension;
target = this->ConvertToOutputPath(target.c_str());
2001-11-28 19:12:15 +03:00
std::string depend = "$(";
depend += this->CreateMakeVariable(name, "_SRC_OBJS") + ") $(" +
this->CreateMakeVariable(name, "_DEPEND_LIBS") + ")";
2001-11-28 19:12:15 +03:00
std::string command =
"$(CMAKE_CXX_COMPILER) ";
2001-12-04 01:01:40 +03:00
command += " $(CMAKE_LINKER_FLAGS) -e" + target;
if(cmSystemTools::IsOn(m_Makefile->GetDefinition("BUILD_SHARED_LIBS")))
{
command += " $(CMAKE_SHLIB_CFLAGS) ";
}
2001-11-28 19:12:15 +03:00
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();
delete [] linklibs.str();
command += " $(" + this->CreateMakeVariable(name, "_SRC_OBJS") + ")";
2001-11-28 19:12:15 +03:00
std::string comment = "rule to build executable: ";
comment += name;
2001-12-07 18:58:06 +03:00
std::string customCommands = this->CreateTargetRules(t, name);
const char* cc = 0;
if(customCommands.size() > 0)
{
cc = customCommands.c_str();
}
2001-11-28 19:12:15 +03:00
this->OutputMakeRule(fout,
comment.c_str(),
target.c_str(),
depend.c_str(),
2001-12-07 18:58:06 +03:00
command.c_str(), cc);
2001-11-28 19:12:15 +03:00
}
2001-12-01 00:48:52 +03:00
std::string cmBorlandMakefileGenerator::GetOutputExtension(const char* s)
2001-11-28 19:12:15 +03:00
{
std::string sourceExtension = s;
if(sourceExtension == "def")
{
return "";
}
if(sourceExtension == "ico" || sourceExtension == "rc2")
{
return "";
}
if(sourceExtension == "rc")
{
return ".res";
}
return ".obj";
}
2001-12-01 00:48:52 +03:00
bool cmBorlandMakefileGenerator::SamePath(const char* path1, const char* path2)
2001-11-28 19:12:15 +03:00
{
// 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 cmBorlandMakefileGenerator::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;
}