in progress
This commit is contained in:
Ken Martin
parent
3ffc4b2ee1
commit
a888ba53fa
|
|
@ -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.
|
||||
|
||||
=========================================================================*/
|
||||
#include "cmGlobalNMakeMakefileGenerator.h"
|
||||
#include "cmLocalNMakeMakefileGenerator.h"
|
||||
#include "cmMakefile.h"
|
||||
|
||||
void cmGlobalNMakeMakefileGenerator::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;
|
||||
}
|
||||
if(!this->GetLanguageEnabled("CXX"))
|
||||
{
|
||||
std::string fpath =
|
||||
mf->GetDefinition("CMAKE_ROOT");
|
||||
fpath += "/Templates/CMakeNMakeWindowsSystemConfig.cmake";
|
||||
mf->ReadListFile(NULL,fpath.c_str());
|
||||
this->SetLanguageEnabled("CXX");
|
||||
}
|
||||
}
|
||||
|
||||
///! Create a local generator appropriate to this Global Generator
|
||||
cmLocalGenerator *cmGlobalNMakeMakefileGenerator::CreateLocalGenerator()
|
||||
{
|
||||
return new cmLocalNMakeMakefileGenerator;
|
||||
}
|
||||
|
|
@ -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 cmGlobalNMakeMakefileGenerator_h
|
||||
#define cmGlobalNMakeMakefileGenerator_h
|
||||
|
||||
#include "cmGlobalUNIXMakefileGenerator.h"
|
||||
|
||||
/** \class cmGlobalNMakeMakefileGenerator
|
||||
* \brief Write a NMake makefiles.
|
||||
*
|
||||
* cmGlobalNMakeMakefileGenerator manages nmake build process for a tree
|
||||
*/
|
||||
class cmGlobalNMakeMakefileGenerator : public cmGlobalUnixMakefileGenerator
|
||||
{
|
||||
public:
|
||||
///! Get the name for the generator.
|
||||
virtual const char* GetName() {
|
||||
return cmGlobalNMakeMakefileGenerator::GetActualName();}
|
||||
static const char* GetActualName() {return "NMake 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
|
||||
|
|
@ -0,0 +1,89 @@
|
|||
/*=========================================================================
|
||||
|
||||
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 "cmGlobalUnixMakefileGenerator.h"
|
||||
#include "cmLocalUnixMakefileGenerator.h"
|
||||
#include "cmMakefile.h"
|
||||
|
||||
void cmGlobalUnixMakefileGenerator::EnableLanguage(const char* lang,
|
||||
cmMakefile *mf)
|
||||
{
|
||||
if (!m_LanguagesEnabled)
|
||||
{
|
||||
m_LanguagesEnabled = true;
|
||||
|
||||
// see man putenv for explaination of this stupid code....
|
||||
static char envCXX[5000];
|
||||
static char envCC[5000];
|
||||
if(mf->GetDefinition("CMAKE_CXX_COMPILER"))
|
||||
{
|
||||
std::string env = "CXX=${CMAKE_CXX_COMPILER}";
|
||||
mf->ExpandVariablesInString(env);
|
||||
strncpy(envCXX, env.c_str(), 4999);
|
||||
envCXX[4999] = 0;
|
||||
putenv(envCXX);
|
||||
}
|
||||
if(mf->GetDefinition("CMAKE_C_COMPILER"))
|
||||
{
|
||||
std::string env = "CC=${CMAKE_C_COMPILER}";
|
||||
mf->ExpandVariablesInString(env);
|
||||
strncpy(envCC, env.c_str(), 4999);
|
||||
envCC[4999] = 0;
|
||||
putenv(envCC);
|
||||
}
|
||||
std::string output;
|
||||
std::string root
|
||||
= cmSystemTools::ConvertToOutputPath(mf->GetDefinition("CMAKE_ROOT"));
|
||||
// if no lang specified use CXX
|
||||
if(!lang )
|
||||
{
|
||||
lang = "CXX";
|
||||
}
|
||||
// if CXX or C, then enable C
|
||||
if((!this->GetLanguageEnabled(lang) && lang[0] == 'C'))
|
||||
{
|
||||
std::string cmd = root;
|
||||
cmd += "/Templates/cconfigure";
|
||||
cmSystemTools::RunCommand(cmd.c_str(), output,
|
||||
cmSystemTools::ConvertToOutputPath(mf->GetHomeOutputDirectory()).c_str());
|
||||
std::string fpath = mf->GetHomeOutputDirectory();
|
||||
fpath += "/CCMakeSystemConfig.cmake";
|
||||
mf->ReadListFile(NULL,fpath.c_str());
|
||||
this->SetLanguageEnabled("C");
|
||||
}
|
||||
// if CXX
|
||||
if(!this->GetLanguageEnabled(lang) || strcmp(lang, "CXX") == 0)
|
||||
{
|
||||
std::string cmd = root;
|
||||
cmd += "/Templates/cxxconfigure";
|
||||
cmSystemTools::RunCommand(cmd.c_str(), output,
|
||||
cmSystemTools::ConvertToOutputPath(mf->GetHomeOutputDirectory()).c_str());
|
||||
std::string fpath = mf->GetHomeOutputDirectory();
|
||||
fpath += "/CXXCMakeSystemConfig.cmake";
|
||||
mf->ReadListFile(NULL,fpath.c_str());
|
||||
this->SetLanguageEnabled("CXX");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
///! Create a local generator appropriate to this Global Generator
|
||||
cmLocalGenerator *cmGlobalUnixMakefileGenerator::CreateLocalGenerator()
|
||||
{
|
||||
cmLocalGenerator *lg = new cmLocalUnixMakefileGenerator;
|
||||
lg->SetGlobalGenerator(this);
|
||||
return lg;
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
/*=========================================================================
|
||||
|
||||
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 cmGlobalUnixMakefileGenerator_h
|
||||
#define cmGlobalUnixMakefileGenerator_h
|
||||
|
||||
#include "cmGlobalGenerator.h"
|
||||
|
||||
/** \class cmGlobalUnixMakefileGenerator
|
||||
* \brief Write a Unix makefiles.
|
||||
*
|
||||
* cmGlobalUnixMakefileGenerator manages UNIX build process for a tree
|
||||
*/
|
||||
class cmGlobalUnixMakefileGenerator : public cmGlobalGenerator
|
||||
{
|
||||
public:
|
||||
///! Get the name for the generator.
|
||||
virtual const char* GetName() {
|
||||
return cmGlobalUnixMakefileGenerator::GetActualName();}
|
||||
static const char* GetActualName() {return "Unix 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
|
||||
|
|
@ -0,0 +1,707 @@
|
|||
/*=========================================================================
|
||||
|
||||
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 "cmLocalNMakeMakefileGenerator.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"
|
||||
|
||||
|
||||
cmLocalNMakeMakefileGenerator::cmLocalNMakeMakefileGenerator()
|
||||
{
|
||||
this->SetLibraryPathOption("@CMAKE_C_LIBPATH_FLAG@"); // Use @ here
|
||||
this->SetObjectFileExtension("$(CMAKE_OBJECT_FILE_SUFFIX)");
|
||||
this->SetExecutableExtension("$(CMAKE_EXECUTABLE_SUFFIX)");
|
||||
this->SetLibraryPrefix("");
|
||||
this->SetStaticLibraryExtension("$(CMAKE_STATICLIB_SUFFIX)");
|
||||
this->SetSharedLibraryExtension("$(CMAKE_SHLIB_SUFFIX)");
|
||||
}
|
||||
|
||||
cmLocalNMakeMakefileGenerator::~cmLocalNMakeMakefileGenerator()
|
||||
{
|
||||
}
|
||||
|
||||
// convert to windows short paths if there are spaces
|
||||
// in path
|
||||
std::string cmLocalNMakeMakefileGenerator::ShortPath(const char* path)
|
||||
{
|
||||
std::string ret = path;
|
||||
// if there are no spaces in path, then just
|
||||
// call ConvertToOutputPath
|
||||
if(ret.find(' ') == std::string::npos)
|
||||
{
|
||||
return cmSystemTools::ConvertToOutputPath(path);
|
||||
}
|
||||
|
||||
// if there are spaces then call GetShortPathName to get rid of them
|
||||
if(!cmSystemTools::GetShortPath(path, ret))
|
||||
{
|
||||
// if GetShortPathName failed for some reason use
|
||||
// ConvertToOutputPath instead which will at least escape the spaces
|
||||
ret = cmSystemTools::ConvertToOutputPath(path);
|
||||
return ret;
|
||||
}
|
||||
ret = cmSystemTools::ConvertToOutputPath(ret.c_str());
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
// convert a command to a short path if it has spaces
|
||||
// this separates the arguments from the command and puts
|
||||
// them back together
|
||||
std::string cmLocalNMakeMakefileGenerator::ShortPathCommand(const char* command)
|
||||
{
|
||||
if (!command)
|
||||
{
|
||||
return "";
|
||||
}
|
||||
if(!strchr(command, ' '))
|
||||
{
|
||||
return command;
|
||||
}
|
||||
cmRegularExpression reg("^\"([^\"]*)\"(.*)");
|
||||
if(reg.find(command))
|
||||
{
|
||||
std::string c = reg.match(1);
|
||||
cmRegularExpression removeIntDir("(.*)(/|\\\\)\\$\\(IntDir\\)(.*)");
|
||||
if(removeIntDir.find(c))
|
||||
{
|
||||
c = removeIntDir.match(1) + removeIntDir.match(3);
|
||||
}
|
||||
std::string unixPath = c;
|
||||
// since the command may already be a windows path, convert it
|
||||
// to unix so we can use SplitProgramPath on it.
|
||||
cmSystemTools::ConvertToUnixSlashes(unixPath);
|
||||
std::string path, file;
|
||||
cmSystemTools::SplitProgramPath(unixPath.c_str(), path, file);
|
||||
// do a short path on the directory, because ShortPath will
|
||||
// not work for files that do not exist
|
||||
path = this->ShortPath(path.c_str());
|
||||
// now put the two back together
|
||||
path += "\\";
|
||||
path += file;
|
||||
std::string ret = path;
|
||||
std::string args = reg.match(2);
|
||||
ret += args;
|
||||
return ret;
|
||||
}
|
||||
return command;
|
||||
}
|
||||
|
||||
void cmLocalNMakeMakefileGenerator::OutputMakeVariables(std::ostream& fout)
|
||||
{
|
||||
fout << "# NMake Makefile generated by cmake\n";
|
||||
const char* variables =
|
||||
"# general variables used in the makefile\n"
|
||||
"\n"
|
||||
"# Path to cmake\n"
|
||||
"MAKESILENT = /nologo\n"
|
||||
"CMAKE_STANDARD_WINDOWS_LIBRARIES = @CMAKE_STANDARD_WINDOWS_LIBRARIES@\n"
|
||||
"CMAKE_C_FLAGS = @CMAKE_C_FLAGS@ @BUILD_FLAGS@ -DWIN32\n"
|
||||
"CMAKE_C_LINK_EXECUTABLE_FLAG = @CMAKE_C_LINK_EXECUTABLE_FLAG@\n"
|
||||
"CMAKE_CXX_FLAGS = @CMAKE_CXX_FLAGS@ -DWIN32 @BUILD_FLAGS@\n"
|
||||
"CMAKE_LINKER_FLAGS = @CMAKE_LINKER_FLAGS@ @LINKER_BUILD_FLAGS@\n"
|
||||
"CMAKE_LINKER_SHARED_LIBRARY_FLAG = @CMAKE_LINKER_SHARED_LIBRARY_FLAG@\n"
|
||||
"CMAKE_LIBRARY_MANAGER_FLAGS = @CMAKE_LIBRARY_MANAGER_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"
|
||||
"!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);
|
||||
fout << replaceVars.c_str();
|
||||
std::string ccompiler = m_Makefile->GetDefinition("CMAKE_C_COMPILER");
|
||||
fout << "CMAKE_C_COMPILER = "
|
||||
<< this->ShortPath(ccompiler.c_str()) << "\n";
|
||||
|
||||
std::string cxxcompiler = m_Makefile->GetDefinition("CMAKE_CXX_COMPILER");
|
||||
fout << "CMAKE_CXX_COMPILER = "
|
||||
<< this->ShortPath(cxxcompiler.c_str()) << "\n";
|
||||
|
||||
std::string linker = m_Makefile->GetDefinition("CMAKE_LINKER");
|
||||
fout << "CMAKE_LINKER = " <<
|
||||
this->ShortPath(linker.c_str()) << "\n";
|
||||
|
||||
std::string lib_manager = m_Makefile->GetDefinition("CMAKE_LIBRARY_MANAGER");
|
||||
fout << "CMAKE_LIBRARY_MANAGER = "
|
||||
<< this->ShortPath(lib_manager.c_str()) << "\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";
|
||||
|
||||
if(m_Makefile->GetDefinition("CMAKE_EDIT_COMMAND"))
|
||||
{
|
||||
fout << "CMAKE_EDIT_COMMAND = "
|
||||
<< this->ShortPath(m_Makefile->GetDefinition("CMAKE_EDIT_COMMAND"))
|
||||
<< "\n";
|
||||
}
|
||||
|
||||
fout << "CMAKE_CURRENT_SOURCE = "
|
||||
<< this->ShortPath(m_Makefile->GetStartDirectory() )
|
||||
<< "\n";
|
||||
fout << "CMAKE_CURRENT_BINARY = "
|
||||
<< this->ShortPath(m_Makefile->GetStartOutputDirectory())
|
||||
<< "\n";
|
||||
fout << "CMAKE_SOURCE_DIR = "
|
||||
<< this->ShortPath(m_Makefile->GetHomeDirectory()) << "\n";
|
||||
fout << "CMAKE_BINARY_DIR = "
|
||||
<< this->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::ConvertToOutputPath(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 cmLocalNMakeMakefileGenerator::BuildInSubDirectory(std::ostream& fout,
|
||||
const char* directory,
|
||||
const char* target1,
|
||||
const char* target2,
|
||||
bool silent)
|
||||
{
|
||||
if(target1)
|
||||
{
|
||||
std::string dir = cmSystemTools::ConvertToOutputPath(directory);
|
||||
fout << "\tif not exist \"" << dir << "\\$(NULL)\""
|
||||
<< " "
|
||||
<< "$(MAKE) $(MAKESILENT) rebuild_cache\n";
|
||||
if (!silent)
|
||||
{
|
||||
fout << "\techo " << directory << ": building " << target1 << "\n";
|
||||
}
|
||||
fout << "\tcd " << dir << "\n"
|
||||
<< "\t$(MAKE) -$(MAKEFLAGS) $(MAKESILENT) " << target1 << "\n";
|
||||
}
|
||||
if(target2)
|
||||
{
|
||||
if (!silent)
|
||||
{
|
||||
fout << "\techo " << directory << ": building " << target2 << "\n";
|
||||
}
|
||||
fout << "\t$(MAKE) -$(MAKEFLAGS) $(MAKESILENT) " << target2 << "\n";
|
||||
}
|
||||
std::string currentDir = m_Makefile->GetCurrentOutputDirectory();
|
||||
fout << "\tcd " << cmSystemTools::ConvertToOutputPath(currentDir.c_str()) << "\n\n";
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
// This needs to be overriden because nmake requires commands to be quoted
|
||||
// if the are full paths to the executable????
|
||||
|
||||
void cmLocalNMakeMakefileGenerator::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)
|
||||
{
|
||||
std::string short_command;
|
||||
if (command)
|
||||
{
|
||||
short_command = ShortPathCommand(command);
|
||||
command = short_command.c_str();
|
||||
}
|
||||
|
||||
std::string short_command2;
|
||||
if (command2)
|
||||
{
|
||||
short_command2 = ShortPathCommand(command2);
|
||||
command2 = short_command2.c_str();
|
||||
}
|
||||
|
||||
std::string short_command3;
|
||||
if (command3)
|
||||
{
|
||||
short_command3 = ShortPathCommand(command3);
|
||||
command3 = short_command3.c_str();
|
||||
}
|
||||
|
||||
std::string short_command4;
|
||||
if (command4)
|
||||
{
|
||||
short_command4 = ShortPathCommand(command4);
|
||||
command4 = short_command4.c_str();
|
||||
}
|
||||
|
||||
cmLocalUnixMakefileGenerator::OutputMakeRule(fout, comment,
|
||||
target, depends,
|
||||
command, command2,
|
||||
command3, command4);
|
||||
return;
|
||||
}
|
||||
|
||||
void
|
||||
cmLocalNMakeMakefileGenerator::
|
||||
OutputBuildObjectFromSource(std::ostream& fout,
|
||||
const char* shortName,
|
||||
const cmSourceFile& source,
|
||||
const char* extraCompileFlags,
|
||||
bool shared)
|
||||
{
|
||||
// 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());
|
||||
|
||||
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 += "$(INCLUDE_FLAGS) -c ";
|
||||
compileCommand +=
|
||||
cmSystemTools::ConvertToOutputPath(source.GetFullPath().c_str());
|
||||
|
||||
// Need to get the definition here because this value might have
|
||||
// trailing space (since it is directly prepended to the filename)
|
||||
std::string output_object_file_flag =
|
||||
m_Makefile->GetDefinition("CMAKE_C_OUTPUT_OBJECT_FILE_FLAG");
|
||||
m_Makefile->ExpandVariablesInString(output_object_file_flag);
|
||||
|
||||
compileCommand += " " + output_object_file_flag;
|
||||
compileCommand += objectFile;
|
||||
}
|
||||
else if (ext == "rc")
|
||||
{
|
||||
compileCommand = "$(RC) $(INCLUDE_FLAGS) /fo\"";
|
||||
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 += "$(INCLUDE_FLAGS) -c ";
|
||||
compileCommand +=
|
||||
cmSystemTools::ConvertToOutputPath(source.GetFullPath().c_str());
|
||||
|
||||
// Need to get the definition here because this value might have
|
||||
// trailing space (since it is directly prepended to the filename)
|
||||
std::string output_object_file_flag =
|
||||
m_Makefile->GetDefinition("CMAKE_C_OUTPUT_OBJECT_FILE_FLAG");
|
||||
m_Makefile->ExpandVariablesInString(output_object_file_flag);
|
||||
|
||||
compileCommand += " " + output_object_file_flag;
|
||||
compileCommand += objectFile;
|
||||
}
|
||||
|
||||
this->OutputMakeRule(fout,
|
||||
comment.c_str(),
|
||||
objectFile.c_str(),
|
||||
cmSystemTools::ConvertToOutputPath(
|
||||
source.GetFullPath().c_str()).c_str(),
|
||||
compileCommand.c_str());
|
||||
}
|
||||
|
||||
void cmLocalNMakeMakefileGenerator::OutputSharedLibraryRule(std::ostream& fout,
|
||||
const char* name,
|
||||
const cmTarget &t)
|
||||
{
|
||||
std::string target = m_LibraryOutputPath + name + m_SharedLibraryExtension;
|
||||
std::string depend = "$(";
|
||||
depend += this->CreateMakeVariable(name, "_SRC_OBJS");
|
||||
depend += ") $(" + this->CreateMakeVariable(name, "_DEPEND_LIBS") + ")";
|
||||
|
||||
// Need to get the definition here because this value might have
|
||||
// trailing space (since it is directly prepended to the filename)
|
||||
std::string linker_output_file_flag =
|
||||
m_Makefile->GetDefinition("CMAKE_LINKER_OUTPUT_FILE_FLAG");
|
||||
m_Makefile->ExpandVariablesInString(linker_output_file_flag);
|
||||
|
||||
std::string command = "$(CMAKE_LINKER) $(CMAKE_LINKER_SHARED_LIBRARY_FLAG)";
|
||||
|
||||
bool hide_param = m_Makefile->IsOn("CMAKE_LINKER_HIDE_PARAMETERS");
|
||||
if (hide_param)
|
||||
{
|
||||
command += " @<<\n\t";
|
||||
}
|
||||
|
||||
command += " $(CMAKE_LINKER_FLAGS) " + linker_output_file_flag;
|
||||
|
||||
std::string dllpath = m_LibraryOutputPath + std::string(name) + m_SharedLibraryExtension;
|
||||
command += cmSystemTools::ConvertToOutputPath(dllpath.c_str());
|
||||
|
||||
command += " $(" + this->CreateMakeVariable(name, "_SRC_OBJS") + ") ";
|
||||
|
||||
cmStringStream linklibs;
|
||||
this->OutputLinkLibraries(linklibs, name, t);
|
||||
command += 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";
|
||||
if (hide_param)
|
||||
{
|
||||
command += "<<\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(), cc);
|
||||
}
|
||||
|
||||
void cmLocalNMakeMakefileGenerator::OutputModuleLibraryRule(std::ostream& fout,
|
||||
const char* name,
|
||||
const cmTarget &target)
|
||||
{
|
||||
this->OutputSharedLibraryRule(fout, name, target);
|
||||
}
|
||||
|
||||
void cmLocalNMakeMakefileGenerator::OutputStaticLibraryRule(std::ostream& fout,
|
||||
const char* name,
|
||||
const cmTarget &t)
|
||||
{
|
||||
std::string target = m_LibraryOutputPath + std::string(name) + m_StaticLibraryExtension;
|
||||
std::string depend = "$(";
|
||||
depend += this->CreateMakeVariable(name, "_SRC_OBJS") + ") ";
|
||||
|
||||
// Need to get the definition here because this value might have
|
||||
// trailing space (since it is directly prepended to the filename)
|
||||
std::string library_manager_output_file_flag =
|
||||
m_Makefile->GetDefinition("CMAKE_LIBRARY_MANAGER_OUTPUT_FILE_FLAG");
|
||||
m_Makefile->ExpandVariablesInString(library_manager_output_file_flag);
|
||||
|
||||
std::string command = "$(CMAKE_LIBRARY_MANAGER) $(CMAKE_LIBRARY_MANAGER_FLAGS) @<<\n\t " + library_manager_output_file_flag;
|
||||
|
||||
std::string libpath = m_LibraryOutputPath + std::string(name) + m_StaticLibraryExtension;
|
||||
command += cmSystemTools::ConvertToOutputPath(libpath.c_str());
|
||||
|
||||
command += " $(";
|
||||
command += this->CreateMakeVariable(name, "_SRC_OBJS") + ")";
|
||||
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(),
|
||||
command.c_str(), cc);
|
||||
}
|
||||
|
||||
void cmLocalNMakeMakefileGenerator::OutputExecutableRule(std::ostream& fout,
|
||||
const char* name,
|
||||
const cmTarget &t)
|
||||
{
|
||||
std::string target = m_ExecutableOutputPath + name;
|
||||
target += m_ExecutableExtension;
|
||||
std::string depend = "$(";
|
||||
depend += this->CreateMakeVariable(name, "_SRC_OBJS") + ") $(" +
|
||||
this->CreateMakeVariable(name, "_DEPEND_LIBS") + ")";
|
||||
std::string command;
|
||||
if(t.HasCxx())
|
||||
{
|
||||
command = "$(CMAKE_CXX_COMPILER) $(CMAKE_CXX_FLAGS) ";
|
||||
}
|
||||
else
|
||||
{
|
||||
command = "${CMAKE_C_COMPILER} $(CMAKE_C_FLAGS) ";
|
||||
}
|
||||
bool hide_param = m_Makefile->IsOn("CMAKE_LINKER_HIDE_PARAMETERS");
|
||||
if (hide_param)
|
||||
{
|
||||
command += " @<<\n\t";
|
||||
}
|
||||
|
||||
command += "$(" + this->CreateMakeVariable(name, "_SRC_OBJS") + ") ";
|
||||
std::string path = m_ExecutableOutputPath + name + m_ExecutableExtension;
|
||||
|
||||
// Need to get the definition here because this value might have
|
||||
// trailing space (since it is directly prepended to the filename)
|
||||
std::string output_executable_file_flag =
|
||||
m_Makefile->GetDefinition("CMAKE_C_OUTPUT_EXECUTABLE_FILE_FLAG");
|
||||
m_Makefile->ExpandVariablesInString(output_executable_file_flag);
|
||||
|
||||
command += " " + output_executable_file_flag +
|
||||
cmSystemTools::ConvertToOutputPath(path.c_str());
|
||||
|
||||
command += " $(CMAKE_C_LINK_EXECUTABLE_FLAG) $(CMAKE_LINKER_FLAGS) ";
|
||||
if(t.GetType() == cmTarget::WIN32_EXECUTABLE)
|
||||
{
|
||||
command += " /subsystem:windows ";
|
||||
}
|
||||
|
||||
cmStringStream linklibs;
|
||||
this->OutputLinkLibraries(linklibs, 0, t);
|
||||
command += linklibs.str();
|
||||
|
||||
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();
|
||||
}
|
||||
if (hide_param)
|
||||
{
|
||||
command += "\n";
|
||||
command += "<<\n";
|
||||
}
|
||||
this->OutputMakeRule(fout,
|
||||
comment.c_str(),
|
||||
target.c_str(),
|
||||
depend.c_str(),
|
||||
command.c_str(), cc);
|
||||
}
|
||||
|
||||
|
||||
void cmLocalNMakeMakefileGenerator::OutputLinkLibraries(std::ostream& fout,
|
||||
const char* targetLibrary,
|
||||
const cmTarget &tgt)
|
||||
{
|
||||
// Try to emit each search path once
|
||||
std::set<std::string> emitted;
|
||||
|
||||
// Embed runtime search paths if possible and if required.
|
||||
// collect all the flags needed for linking libraries
|
||||
// Do not try if there is no library path option (it is set to -L or
|
||||
// -LIBPATH for some linker, but some others do not even support link
|
||||
// search path).
|
||||
std::string linkLibs;
|
||||
|
||||
// Expand content because this value might have
|
||||
// trailing space (since it is directly prepended to the filename)
|
||||
std::string lib_path_opt = m_LibraryPathOption;
|
||||
m_Makefile->ExpandVariablesInString(lib_path_opt);
|
||||
|
||||
if (lib_path_opt.size())
|
||||
{
|
||||
const std::vector<std::string>& libdirs = tgt.GetLinkDirectories();
|
||||
for(std::vector<std::string>::const_iterator libDir = libdirs.begin();
|
||||
libDir != libdirs.end(); ++libDir)
|
||||
{
|
||||
std::string libpath = ShortPath(libDir->c_str());
|
||||
if(emitted.insert(libpath).second)
|
||||
{
|
||||
linkLibs += lib_path_opt;
|
||||
cmSystemTools::ConvertToOutputPath(libpath.c_str());
|
||||
linkLibs += libpath;
|
||||
linkLibs += " ";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::string librariesLinked;
|
||||
const cmTarget::LinkLibraries& libs = tgt.GetLinkLibraries();
|
||||
for(cmTarget::LinkLibraries::const_iterator lib = libs.begin();
|
||||
lib != libs.end(); ++lib)
|
||||
{
|
||||
// Don't link the library against itself!
|
||||
if(targetLibrary && (lib->first == targetLibrary)) continue;
|
||||
|
||||
// ** should fix this later, it should check to see if this is
|
||||
// a debug build and add the library
|
||||
// don't look at debug libraries
|
||||
// if (lib->second == cmTarget::DEBUG) continue;
|
||||
// skip zero size library entries, this may happen
|
||||
// if a variable expands to nothing.
|
||||
if (lib->first.size() == 0) continue;
|
||||
if(emitted.insert(lib->first).second)
|
||||
{
|
||||
std::string regexp = ".*\\";
|
||||
regexp += m_Makefile->GetDefinition("CMAKE_STATICLIB_SUFFIX");
|
||||
regexp += "$";
|
||||
cmRegularExpression reg(regexp.c_str());
|
||||
// if it ends in .lib, then it is a full path and should
|
||||
// be escaped, and does not need .lib added
|
||||
if(reg.find(lib->first))
|
||||
{
|
||||
librariesLinked += ShortPath(lib->first.c_str());
|
||||
librariesLinked += " ";
|
||||
}
|
||||
else
|
||||
{
|
||||
librariesLinked += m_LibraryLinkOption;
|
||||
librariesLinked += lib->first;
|
||||
librariesLinked += m_StaticLibraryExtension + " ";
|
||||
}
|
||||
}
|
||||
}
|
||||
linkLibs += librariesLinked;
|
||||
fout << linkLibs;
|
||||
fout << "$(CMAKE_STANDARD_WINDOWS_LIBRARIES) ";
|
||||
}
|
||||
|
||||
|
||||
std::string cmLocalNMakeMakefileGenerator::GetOutputExtension(const char* s)
|
||||
{
|
||||
std::string sourceExtension = s;
|
||||
if(sourceExtension == "def")
|
||||
{
|
||||
return "";
|
||||
}
|
||||
if(sourceExtension == "ico" || sourceExtension == "rc2")
|
||||
{
|
||||
return "";
|
||||
}
|
||||
if(sourceExtension == "rc")
|
||||
{
|
||||
return ".res";
|
||||
}
|
||||
return m_ObjectFileExtension;
|
||||
}
|
||||
|
||||
|
||||
void cmLocalNMakeMakefileGenerator::OutputIncludeMakefile(std::ostream& fout,
|
||||
const char* file)
|
||||
{
|
||||
fout << "!include " << file << "\n";
|
||||
}
|
||||
|
||||
bool cmLocalNMakeMakefileGenerator::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 cmLocalNMakeMakefileGenerator::OutputBuildTargetInDir(std::ostream& fout,
|
||||
const char* path,
|
||||
const char* library,
|
||||
const char* fullpath,
|
||||
const char* libOutPath)
|
||||
{
|
||||
const char* makeTarget = library;
|
||||
std::string currentDir =
|
||||
cmSystemTools::ConvertToOutputPath(m_Makefile->GetCurrentOutputDirectory());
|
||||
std::string wpath = cmSystemTools::ConvertToOutputPath(path);
|
||||
std::string wfullpath = cmSystemTools::ConvertToOutputPath(fullpath);
|
||||
if(libOutPath && strcmp( libOutPath, "" ) != 0)
|
||||
{
|
||||
makeTarget = wfullpath.c_str();
|
||||
}
|
||||
fout << wfullpath
|
||||
<< ":\n\tcd " << wpath << "\n"
|
||||
<< "\t$(MAKE) -$(MAKEFLAGS) $(MAKESILENT) cmake.depends\n"
|
||||
<< "\t$(MAKE) -$(MAKEFLAGS) $(MAKESILENT) cmake.check_depends\n"
|
||||
<< "\t$(MAKE) -$(MAKEFLAGS) $(MAKESILENT) -f cmake.check_depends\n"
|
||||
<< "\t$(MAKE) $(MAKESILENT) " << makeTarget
|
||||
<< "\n\tcd " << currentDir << "\n";
|
||||
}
|
||||
|
||||
std::string cmLocalNMakeMakefileGenerator::CreateMakeVariable(const char* s, const char* s2)
|
||||
{
|
||||
std::string ret= std::string(s) + std::string(s2);
|
||||
cmSystemTools::ReplaceString(ret, "-", "_");
|
||||
return ret;
|
||||
}
|
||||
|
||||
std::string cmLocalNMakeMakefileGenerator::LowerCasePath(const char* path)
|
||||
{
|
||||
return cmSystemTools::LowerCase(path);
|
||||
}
|
||||
|
|
@ -0,0 +1,90 @@
|
|||
/*=========================================================================
|
||||
|
||||
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 cmNMakeMakefileGenerator_h
|
||||
#define cmNMakeMakefileGenerator_h
|
||||
|
||||
#include "cmLocalUnixMakefileGenerator.h"
|
||||
|
||||
/** \class cmLocalNMakeMakefileGenerator
|
||||
* \brief Write an NMake makefile.
|
||||
*
|
||||
* cmLocalNMakeMakefileGenerator produces a Unix makefile from its
|
||||
* member m_Makefile.
|
||||
*/
|
||||
class cmLocalNMakeMakefileGenerator : public cmLocalUnixMakefileGenerator
|
||||
{
|
||||
public:
|
||||
///! Set cache only and recurse to false by default.
|
||||
cmLocalNMakeMakefileGenerator();
|
||||
|
||||
virtual ~cmLocalNMakeMakefileGenerator();
|
||||
|
||||
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,
|
||||
const char* target1,
|
||||
const char* target2,
|
||||
bool silent = false);
|
||||
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 void OutputLinkLibraries(std::ostream& fout,
|
||||
const char* targetLibrary,
|
||||
const cmTarget &tgt);
|
||||
virtual std::string GetOutputExtension(const char* sourceExtension);
|
||||
virtual void OutputIncludeMakefile(std::ostream&, const char* file);
|
||||
virtual void OutputBuildTargetInDir(std::ostream& fout,
|
||||
const char* path,
|
||||
const char* library,
|
||||
const char* fullpath,
|
||||
const char* outputPath);
|
||||
///! 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;}
|
||||
void SetLibraryLinkOption(const char* lib){ m_LibraryLinkOption = lib;}
|
||||
|
||||
virtual std::string CreateMakeVariable(const char* s, const char* s2);
|
||||
virtual std::string LowerCasePath(const char* path);
|
||||
private:
|
||||
std::string m_LibraryPathOption;// option to specifiy a link path -LIBPATH
|
||||
std::string m_LibraryLinkOption; // option to specify a library (like -l, empty for nmake)
|
||||
};
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,158 @@
|
|||
/*=========================================================================
|
||||
|
||||
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 cmLocalUnixMakefileGenerator_h
|
||||
#define cmLocalUnixMakefileGenerator_h
|
||||
|
||||
#include "cmLocalGenerator.h"
|
||||
|
||||
class cmMakeDepend;
|
||||
class cmTarget;
|
||||
class cmSourceFile;
|
||||
|
||||
/** \class cmLocalUnixMakefileGenerator
|
||||
* \brief Write a LocalUnix makefiles.
|
||||
*
|
||||
* cmLocalUnixMakefileGenerator produces a LocalUnix makefile from its
|
||||
* member m_Makefile.
|
||||
*/
|
||||
class cmLocalUnixMakefileGenerator : public cmLocalGenerator
|
||||
{
|
||||
public:
|
||||
///! Set cache only and recurse to false by default.
|
||||
cmLocalUnixMakefileGenerator();
|
||||
|
||||
virtual ~cmLocalUnixMakefileGenerator();
|
||||
|
||||
/**
|
||||
* Generate the makefile for this directory. fromTheTop indicates if this
|
||||
* is being invoked as part of a global Generate or specific to this
|
||||
* directory. The difference is that when done from the Top we might skip
|
||||
* some steps to save time, such as dependency generation for the
|
||||
* makefiles. This is done by a direct invocation from make.
|
||||
*/
|
||||
virtual void Generate(bool fromTheTop);
|
||||
|
||||
/**
|
||||
* Output the depend information for all the classes
|
||||
* in the makefile. These would have been generated
|
||||
* by the class cmMakeDepend.
|
||||
*/
|
||||
virtual bool OutputObjectDepends(std::ostream&);
|
||||
|
||||
/**
|
||||
* Output the check depend information for all the classes
|
||||
* in the makefile. These would have been generated
|
||||
* by the class cmMakeDepend.
|
||||
*/
|
||||
virtual void OutputCheckDepends(std::ostream&);
|
||||
|
||||
protected:
|
||||
virtual void ProcessDepends(const cmMakeDepend &md);
|
||||
virtual void OutputMakefile(const char* file, bool withDepends);
|
||||
virtual void OutputTargetRules(std::ostream& fout);
|
||||
virtual void OutputLinkLibraries(std::ostream&, const char* name, const cmTarget &);
|
||||
|
||||
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 void OutputUtilityRule(std::ostream&, const char* name,
|
||||
const cmTarget &);
|
||||
|
||||
virtual void OutputTargets(std::ostream&);
|
||||
virtual void OutputSubDirectoryRules(std::ostream&);
|
||||
virtual void OutputDependLibs(std::ostream&);
|
||||
virtual void OutputLibDepend(std::ostream&, const char*);
|
||||
virtual void OutputExeDepend(std::ostream&, const char*);
|
||||
virtual void OutputCustomRules(std::ostream&);
|
||||
virtual void OutputMakeVariables(std::ostream&);
|
||||
virtual void OutputMakeRules(std::ostream&);
|
||||
virtual void OutputInstallRules(std::ostream&);
|
||||
virtual void OutputSourceObjectBuildRules(std::ostream& fout);
|
||||
virtual void OutputBuildObjectFromSource(std::ostream& fout,
|
||||
const char* shortName,
|
||||
const cmSourceFile& source,
|
||||
const char* extraCompileFlags,
|
||||
bool sharedTarget);
|
||||
|
||||
virtual void BuildInSubDirectory(std::ostream& fout,
|
||||
const char* directory,
|
||||
const char* target1,
|
||||
const char* target2,
|
||||
bool silent = false);
|
||||
|
||||
virtual void OutputSubDirectoryVars(std::ostream& fout,
|
||||
const char* var,
|
||||
const char* target,
|
||||
const char* target1,
|
||||
const char* target2,
|
||||
const char* depend,
|
||||
const std::vector<std::string>&
|
||||
SubDirectories,
|
||||
bool silent = false);
|
||||
|
||||
virtual void OutputMakeRule(std::ostream&,
|
||||
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 OutputBuildTargetInDir(std::ostream& fout,
|
||||
const char* path,
|
||||
const char* library,
|
||||
const char* fullpath,
|
||||
const char* outputPath);
|
||||
///! return true if the two paths are the same
|
||||
virtual bool SamePath(const char* path1, const char* path2);
|
||||
virtual std::string GetOutputExtension(const char* sourceExtension);
|
||||
virtual void OutputIncludeMakefile(std::ostream&, const char* file);
|
||||
void SetObjectFileExtension(const char* e) { m_ObjectFileExtension = e;}
|
||||
void SetExecutableExtension(const char* e) { m_ExecutableExtension = e;}
|
||||
void SetStaticLibraryExtension(const char* e) {m_StaticLibraryExtension = e;}
|
||||
void SetSharedLibraryExtension(const char* e) {m_SharedLibraryExtension = e;}
|
||||
void SetLibraryPrefix(const char* e) { m_LibraryPrefix = e;}
|
||||
std::string CreateTargetRules(const cmTarget &target,
|
||||
const char* targetName);
|
||||
virtual std::string CreateMakeVariable(const char* s, const char* s2)
|
||||
{
|
||||
return std::string(s) + std::string(s2);
|
||||
}
|
||||
|
||||
///! if the OS is case insensitive then return a lower case of the path.
|
||||
virtual std::string LowerCasePath(const char* path)
|
||||
{
|
||||
return std::string(path);
|
||||
}
|
||||
|
||||
protected:
|
||||
std::string m_ExecutableOutputPath;
|
||||
std::string m_LibraryOutputPath;
|
||||
std::string m_SharedLibraryExtension;
|
||||
std::string m_ObjectFileExtension;
|
||||
std::string m_ExecutableExtension;
|
||||
std::string m_StaticLibraryExtension;
|
||||
std::string m_LibraryPrefix;
|
||||
private:
|
||||
};
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue