2002-09-04 23:23:56 +04:00
|
|
|
/*=========================================================================
|
|
|
|
|
2002-10-24 02:03:27 +04:00
|
|
|
Program: CMake - Cross-Platform Makefile Generator
|
2002-09-04 23:23:56 +04:00
|
|
|
Module: $RCSfile$
|
|
|
|
Language: C++
|
|
|
|
Date: $Date$
|
|
|
|
Version: $Revision$
|
|
|
|
|
2002-10-24 02:03:27 +04:00
|
|
|
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
|
|
|
|
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
|
2002-09-04 23:23:56 +04: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.
|
|
|
|
|
|
|
|
=========================================================================*/
|
|
|
|
#include "cmGlobalGenerator.h"
|
|
|
|
#include "cmLocalVisualStudio6Generator.h"
|
|
|
|
#include "cmMakefile.h"
|
|
|
|
#include "cmSystemTools.h"
|
|
|
|
#include "cmSourceFile.h"
|
|
|
|
#include "cmCacheManager.h"
|
2003-11-01 00:55:49 +03:00
|
|
|
#include "cmake.h"
|
2002-09-04 23:23:56 +04:00
|
|
|
|
2003-06-23 22:10:12 +04:00
|
|
|
#include <cmsys/RegularExpression.hxx>
|
|
|
|
|
2002-09-04 23:23:56 +04:00
|
|
|
cmLocalVisualStudio6Generator::cmLocalVisualStudio6Generator()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
cmLocalVisualStudio6Generator::~cmLocalVisualStudio6Generator()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-03-18 18:41:41 +03:00
|
|
|
void cmLocalVisualStudio6Generator::Generate()
|
2004-10-21 22:34:02 +04:00
|
|
|
{
|
|
|
|
std::set<cmStdString> lang;
|
|
|
|
lang.insert("C");
|
|
|
|
lang.insert("CXX");
|
|
|
|
this->CreateCustomTargetsAndCommands(lang);
|
2002-09-04 23:23:56 +04:00
|
|
|
this->OutputDSPFile();
|
|
|
|
}
|
|
|
|
|
|
|
|
void cmLocalVisualStudio6Generator::OutputDSPFile()
|
|
|
|
{
|
|
|
|
// If not an in source build, then create the output directory
|
2006-03-15 19:02:08 +03:00
|
|
|
if(strcmp(this->Makefile->GetStartOutputDirectory(),
|
|
|
|
this->Makefile->GetHomeDirectory()) != 0)
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2006-05-12 19:56:09 +04:00
|
|
|
if(!cmSystemTools::MakeDirectory
|
|
|
|
(this->Makefile->GetStartOutputDirectory()))
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
|
|
|
cmSystemTools::Error("Error creating directory ",
|
2006-03-15 19:02:08 +03:00
|
|
|
this->Makefile->GetStartOutputDirectory());
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-18 19:51:23 +03:00
|
|
|
// Setup /I and /LIBPATH options for the resulting DSP file. VS 6
|
|
|
|
// truncates long include paths so make it as short as possible if
|
|
|
|
// the length threatents this problem.
|
|
|
|
unsigned int maxIncludeLength = 3000;
|
|
|
|
bool useShortPath = false;
|
|
|
|
for(int j=0; j < 2; ++j)
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2006-02-18 19:51:23 +03:00
|
|
|
std::vector<std::string> includes;
|
|
|
|
this->GetIncludeDirectories(includes);
|
|
|
|
std::vector<std::string>::iterator i;
|
|
|
|
for(i = includes.begin(); i != includes.end(); ++i)
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
std::string tmp =
|
|
|
|
this->ConvertToOptionallyRelativeOutputPath(i->c_str());
|
2006-02-18 19:51:23 +03:00
|
|
|
if(useShortPath)
|
|
|
|
{
|
|
|
|
cmSystemTools::GetShortPath(tmp.c_str(), tmp);
|
|
|
|
}
|
2006-03-15 19:02:08 +03:00
|
|
|
this->IncludeOptions += " /I ";
|
2002-09-04 23:23:56 +04:00
|
|
|
|
2006-02-18 19:51:23 +03:00
|
|
|
// quote if not already quoted
|
|
|
|
if (tmp[0] != '"')
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
this->IncludeOptions += "\"";
|
|
|
|
this->IncludeOptions += tmp;
|
|
|
|
this->IncludeOptions += "\"";
|
2006-02-18 19:51:23 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
this->IncludeOptions += tmp;
|
2006-02-18 19:51:23 +03:00
|
|
|
}
|
|
|
|
}
|
2006-03-15 19:02:08 +03:00
|
|
|
if(j == 0 && this->IncludeOptions.size() > maxIncludeLength)
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
this->IncludeOptions = "";
|
2006-02-18 19:51:23 +03:00
|
|
|
useShortPath = true;
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2006-02-18 19:51:23 +03:00
|
|
|
break;
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create the DSP or set of DSP's for libraries and executables
|
|
|
|
|
|
|
|
// clear project names
|
2006-03-15 19:02:08 +03:00
|
|
|
this->CreatedProjectNames.clear();
|
2006-01-09 22:40:31 +03:00
|
|
|
// Call TraceVSDependencies on all targets
|
2006-03-15 19:02:08 +03:00
|
|
|
cmTargets &tgts = this->Makefile->GetTargets();
|
2006-01-09 22:40:31 +03:00
|
|
|
for(cmTargets::iterator l = tgts.begin();
|
|
|
|
l != tgts.end(); l++)
|
|
|
|
{
|
2006-02-10 02:42:58 +03:00
|
|
|
// Add a rule to regenerate the build system when the target
|
|
|
|
// specification source changes.
|
|
|
|
const char* suppRegenRule =
|
2006-03-15 19:02:08 +03:00
|
|
|
this->Makefile->GetDefinition("CMAKE_SUPPRESS_REGENERATION");
|
2006-02-10 02:42:58 +03:00
|
|
|
if (!cmSystemTools::IsOn(suppRegenRule))
|
|
|
|
{
|
|
|
|
this->AddDSPBuildRule(l->second);
|
|
|
|
}
|
|
|
|
|
2006-01-09 22:40:31 +03:00
|
|
|
// INCLUDE_EXTERNAL_MSPROJECT command only affects the workspace
|
|
|
|
// so don't build a projectfile for it
|
|
|
|
if ((l->second.GetType() != cmTarget::INSTALL_FILES)
|
|
|
|
&& (l->second.GetType() != cmTarget::INSTALL_PROGRAMS)
|
|
|
|
&& (strncmp(l->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) != 0))
|
|
|
|
{
|
|
|
|
cmTarget& target = l->second;
|
2006-03-15 19:02:08 +03:00
|
|
|
target.TraceVSDependencies(target.GetName(), this->Makefile);
|
2006-01-09 22:40:31 +03:00
|
|
|
}
|
|
|
|
}
|
2006-03-23 21:55:09 +03:00
|
|
|
|
2002-09-04 23:23:56 +04:00
|
|
|
// build any targets
|
|
|
|
for(cmTargets::iterator l = tgts.begin();
|
|
|
|
l != tgts.end(); l++)
|
|
|
|
{
|
|
|
|
switch(l->second.GetType())
|
|
|
|
{
|
|
|
|
case cmTarget::STATIC_LIBRARY:
|
2003-02-07 22:04:16 +03:00
|
|
|
this->SetBuildType(STATIC_LIBRARY, l->first.c_str(), l->second);
|
2002-09-04 23:23:56 +04:00
|
|
|
break;
|
|
|
|
case cmTarget::SHARED_LIBRARY:
|
2002-12-17 20:56:04 +03:00
|
|
|
case cmTarget::MODULE_LIBRARY:
|
2003-02-07 22:04:16 +03:00
|
|
|
this->SetBuildType(DLL, l->first.c_str(), l->second);
|
2002-09-04 23:23:56 +04:00
|
|
|
break;
|
|
|
|
case cmTarget::EXECUTABLE:
|
2003-02-07 22:04:16 +03:00
|
|
|
this->SetBuildType(EXECUTABLE,l->first.c_str(), l->second);
|
2002-09-04 23:23:56 +04:00
|
|
|
break;
|
|
|
|
case cmTarget::UTILITY:
|
2006-02-25 00:20:44 +03:00
|
|
|
case cmTarget::GLOBAL_TARGET:
|
2003-02-07 22:04:16 +03:00
|
|
|
this->SetBuildType(UTILITY, l->first.c_str(), l->second);
|
2002-09-04 23:23:56 +04:00
|
|
|
break;
|
|
|
|
case cmTarget::INSTALL_FILES:
|
2002-10-24 02:03:27 +04:00
|
|
|
break;
|
2002-09-04 23:23:56 +04:00
|
|
|
case cmTarget::INSTALL_PROGRAMS:
|
2002-10-24 02:03:27 +04:00
|
|
|
break;
|
2002-09-04 23:23:56 +04:00
|
|
|
default:
|
2002-10-24 02:03:27 +04:00
|
|
|
cmSystemTools::Error("Bad target type", l->first.c_str());
|
|
|
|
break;
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
|
|
|
// INCLUDE_EXTERNAL_MSPROJECT command only affects the workspace
|
|
|
|
// so don't build a projectfile for it
|
|
|
|
if ((l->second.GetType() != cmTarget::INSTALL_FILES)
|
|
|
|
&& (l->second.GetType() != cmTarget::INSTALL_PROGRAMS)
|
|
|
|
&& (strncmp(l->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) != 0))
|
|
|
|
{
|
|
|
|
// check to see if the dsp is going into a sub-directory
|
|
|
|
std::string::size_type pos = l->first.rfind('/');
|
|
|
|
if(pos != std::string::npos)
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
std::string dir = this->Makefile->GetStartOutputDirectory();
|
2002-09-04 23:23:56 +04:00
|
|
|
dir += "/";
|
|
|
|
dir += l->first.substr(0, pos);
|
|
|
|
if(!cmSystemTools::MakeDirectory(dir.c_str()))
|
|
|
|
{
|
|
|
|
cmSystemTools::Error("Error creating directory ", dir.c_str());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
this->CreateSingleDSP(l->first.c_str(),l->second);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-05-12 19:56:09 +04:00
|
|
|
void cmLocalVisualStudio6Generator::CreateSingleDSP(const char *lname,
|
|
|
|
cmTarget &target)
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
|
|
|
// add to the list of projects
|
|
|
|
std::string pname = lname;
|
2006-03-15 19:02:08 +03:00
|
|
|
this->CreatedProjectNames.push_back(pname);
|
2002-09-04 23:23:56 +04:00
|
|
|
// create the dsp.cmake file
|
|
|
|
std::string fname;
|
2006-03-15 19:02:08 +03:00
|
|
|
fname = this->Makefile->GetStartOutputDirectory();
|
2002-09-04 23:23:56 +04:00
|
|
|
fname += "/";
|
|
|
|
fname += lname;
|
|
|
|
fname += ".dsp";
|
|
|
|
// save the name of the real dsp file
|
|
|
|
std::string realDSP = fname;
|
|
|
|
fname += ".cmake";
|
|
|
|
std::ofstream fout(fname.c_str());
|
|
|
|
if(!fout)
|
|
|
|
{
|
|
|
|
cmSystemTools::Error("Error Writing ", fname.c_str());
|
2004-09-08 00:55:25 +04:00
|
|
|
cmSystemTools::ReportLastSystemError("");
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
|
|
|
this->WriteDSPFile(fout,lname,target);
|
|
|
|
fout.close();
|
|
|
|
// if the dsp file has changed, then write it.
|
|
|
|
cmSystemTools::CopyFileIfDifferent(fname.c_str(), realDSP.c_str());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-02-10 02:42:58 +03:00
|
|
|
void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt)
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2006-02-10 02:42:58 +03:00
|
|
|
std::string dspname = tgt.GetName();
|
2002-09-04 23:23:56 +04:00
|
|
|
dspname += ".dsp.cmake";
|
2006-05-12 19:56:09 +04:00
|
|
|
const char* dsprule =
|
|
|
|
this->Makefile->GetRequiredDefinition("CMAKE_COMMAND");
|
2005-02-22 18:32:44 +03:00
|
|
|
cmCustomCommandLine commandLine;
|
|
|
|
commandLine.push_back(dsprule);
|
2006-03-15 19:02:08 +03:00
|
|
|
std::string makefileIn = this->Makefile->GetStartDirectory();
|
2003-06-03 18:30:23 +04:00
|
|
|
makefileIn += "/";
|
|
|
|
makefileIn += "CMakeLists.txt";
|
2006-04-11 19:06:19 +04:00
|
|
|
std::string comment = "Building Custom Rule ";
|
|
|
|
comment += makefileIn;
|
2003-06-03 18:30:23 +04:00
|
|
|
std::string args;
|
|
|
|
args = "-H";
|
2006-05-12 19:56:09 +04:00
|
|
|
args += this->Convert(this->Makefile->GetHomeDirectory(),
|
|
|
|
START_OUTPUT, SHELL, true);
|
2005-02-22 18:32:44 +03:00
|
|
|
commandLine.push_back(args);
|
2003-06-03 18:30:23 +04:00
|
|
|
args = "-B";
|
2002-09-04 23:23:56 +04:00
|
|
|
args +=
|
2006-03-15 19:02:08 +03:00
|
|
|
this->Convert(this->Makefile->GetHomeOutputDirectory(),
|
2005-06-10 16:41:47 +04:00
|
|
|
START_OUTPUT, SHELL, true);
|
2005-02-22 18:32:44 +03:00
|
|
|
commandLine.push_back(args);
|
2002-09-04 23:23:56 +04:00
|
|
|
|
|
|
|
std::string configFile =
|
2006-03-15 19:02:08 +03:00
|
|
|
this->Makefile->GetRequiredDefinition("CMAKE_ROOT");
|
2002-09-04 23:23:56 +04:00
|
|
|
configFile += "/Templates/CMakeWindowsSystemConfig.cmake";
|
2006-03-15 19:02:08 +03:00
|
|
|
std::vector<std::string> listFiles = this->Makefile->GetListFiles();
|
2002-09-04 23:23:56 +04:00
|
|
|
bool found = false;
|
|
|
|
for(std::vector<std::string>::iterator i = listFiles.begin();
|
|
|
|
i != listFiles.end(); ++i)
|
|
|
|
{
|
|
|
|
if(*i == configFile)
|
|
|
|
{
|
|
|
|
found = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(!found)
|
|
|
|
{
|
|
|
|
listFiles.push_back(configFile);
|
|
|
|
}
|
2005-02-22 18:32:44 +03:00
|
|
|
|
|
|
|
cmCustomCommandLines commandLines;
|
|
|
|
commandLines.push_back(commandLine);
|
2006-02-08 18:58:36 +03:00
|
|
|
const char* no_working_directory = 0;
|
2006-04-11 19:06:19 +04:00
|
|
|
this->Makefile->AddCustomCommandToOutput(dspname.c_str(), listFiles,
|
|
|
|
makefileIn.c_str(), commandLines,
|
|
|
|
comment.c_str(),
|
|
|
|
no_working_directory, true);
|
2006-03-15 19:02:08 +03:00
|
|
|
if(cmSourceFile* file = this->Makefile->GetSource(makefileIn.c_str()))
|
2006-02-15 00:32:20 +03:00
|
|
|
{
|
|
|
|
tgt.GetSourceFiles().push_back(file);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
cmSystemTools::Error("Error adding rule for ", makefileIn.c_str());
|
|
|
|
}
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout,
|
2005-07-13 19:21:30 +04:00
|
|
|
const char *libName,
|
|
|
|
cmTarget &target)
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2005-04-26 19:08:18 +04:00
|
|
|
// For utility targets need custom command since pre- and post-
|
|
|
|
// build does not do anything in Visual Studio 6. In order for the
|
|
|
|
// rules to run in the correct order as custom commands, we need
|
|
|
|
// special care for dependencies. The first rule must depend on all
|
|
|
|
// the dependencies of all the rules. The later rules must each
|
|
|
|
// depend only on the previous rule.
|
2006-02-25 00:20:44 +03:00
|
|
|
if ((target.GetType() == cmTarget::UTILITY ||
|
|
|
|
target.GetType() == cmTarget::GLOBAL_TARGET) &&
|
2005-04-26 19:08:18 +04:00
|
|
|
(!target.GetPreBuildCommands().empty() ||
|
|
|
|
!target.GetPostBuildCommands().empty()))
|
2003-08-08 18:40:11 +04:00
|
|
|
{
|
2005-04-26 19:08:18 +04:00
|
|
|
// Accumulate the dependencies of all the commands.
|
|
|
|
std::vector<std::string> depends;
|
|
|
|
for (std::vector<cmCustomCommand>::const_iterator cr =
|
|
|
|
target.GetPreBuildCommands().begin();
|
|
|
|
cr != target.GetPreBuildCommands().end(); ++cr)
|
|
|
|
{
|
|
|
|
depends.insert(depends.end(),
|
|
|
|
cr->GetDepends().begin(), cr->GetDepends().end());
|
|
|
|
}
|
|
|
|
for (std::vector<cmCustomCommand>::const_iterator cr =
|
|
|
|
target.GetPostBuildCommands().begin();
|
|
|
|
cr != target.GetPostBuildCommands().end(); ++cr)
|
|
|
|
{
|
|
|
|
depends.insert(depends.end(),
|
|
|
|
cr->GetDepends().begin(), cr->GetDepends().end());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add the pre- and post-build commands in order.
|
2003-08-08 18:40:11 +04:00
|
|
|
int count = 1;
|
2005-04-26 19:08:18 +04:00
|
|
|
for (std::vector<cmCustomCommand>::const_iterator cr =
|
|
|
|
target.GetPreBuildCommands().begin();
|
|
|
|
cr != target.GetPreBuildCommands().end(); ++cr)
|
|
|
|
{
|
2006-02-08 20:01:21 +03:00
|
|
|
this->AddUtilityCommandHack(target, count++, depends, *cr);
|
2005-04-26 19:08:18 +04:00
|
|
|
}
|
|
|
|
for (std::vector<cmCustomCommand>::const_iterator cr =
|
|
|
|
target.GetPostBuildCommands().begin();
|
2003-08-08 18:40:11 +04:00
|
|
|
cr != target.GetPostBuildCommands().end(); ++cr)
|
|
|
|
{
|
2006-02-08 20:01:21 +03:00
|
|
|
this->AddUtilityCommandHack(target, count++, depends, *cr);
|
2003-08-08 18:40:11 +04:00
|
|
|
}
|
|
|
|
}
|
2003-06-24 23:24:30 +04:00
|
|
|
|
|
|
|
// trace the visual studio dependencies
|
|
|
|
std::string name = libName;
|
|
|
|
name += ".dsp.cmake";
|
2003-06-03 18:30:23 +04:00
|
|
|
|
2003-06-24 23:24:30 +04:00
|
|
|
// We may be modifying the source groups temporarily, so make a copy.
|
2006-03-15 19:02:08 +03:00
|
|
|
std::vector<cmSourceGroup> sourceGroups = this->Makefile->GetSourceGroups();
|
2003-06-24 23:24:30 +04:00
|
|
|
|
2002-09-04 23:23:56 +04:00
|
|
|
// get the classes from the source lists then add them to the groups
|
2003-06-03 18:30:23 +04:00
|
|
|
std::vector<cmSourceFile*> & classes = target.GetSourceFiles();
|
|
|
|
|
2003-06-16 18:20:48 +04:00
|
|
|
// now all of the source files have been properly assigned to the target
|
|
|
|
// now stick them into source groups using the reg expressions
|
2002-09-04 23:23:56 +04:00
|
|
|
for(std::vector<cmSourceFile*>::iterator i = classes.begin();
|
|
|
|
i != classes.end(); i++)
|
|
|
|
{
|
|
|
|
// Add the file to the list of sources.
|
|
|
|
std::string source = (*i)->GetFullPath();
|
2006-05-12 19:56:09 +04:00
|
|
|
cmSourceGroup& sourceGroup =
|
|
|
|
this->Makefile->FindSourceGroup(source.c_str(), sourceGroups);
|
2003-07-23 23:32:54 +04:00
|
|
|
sourceGroup.AssignSource(*i);
|
2003-06-16 18:20:48 +04:00
|
|
|
// while we are at it, if it is a .rule file then for visual studio 6 we
|
|
|
|
// must generate it
|
|
|
|
if ((*i)->GetSourceExtension() == "rule")
|
|
|
|
{
|
|
|
|
if(!cmSystemTools::FileExists(source.c_str()))
|
|
|
|
{
|
2003-08-01 00:43:53 +04:00
|
|
|
cmSystemTools::ReplaceString(source, "$(IntDir)/", "");
|
2003-06-16 18:20:48 +04:00
|
|
|
#if defined(_WIN32) || defined(__CYGWIN__)
|
|
|
|
std::ofstream fout(source.c_str(),
|
2006-05-12 19:56:09 +04:00
|
|
|
std::ios::binary | std::ios::out
|
|
|
|
| std::ios::trunc);
|
2003-06-16 18:20:48 +04:00
|
|
|
#else
|
|
|
|
std::ofstream fout(source.c_str(),
|
|
|
|
std::ios::out | std::ios::trunc);
|
|
|
|
#endif
|
|
|
|
if(fout)
|
|
|
|
{
|
|
|
|
fout.write("# generated from CMake",22);
|
|
|
|
fout.flush();
|
|
|
|
fout.close();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Write the DSP file's header.
|
|
|
|
this->WriteDSPHeader(fout, libName, target, sourceGroups);
|
|
|
|
|
2003-08-08 18:40:11 +04:00
|
|
|
|
2002-09-04 23:23:56 +04:00
|
|
|
// Loop through every source group.
|
|
|
|
for(std::vector<cmSourceGroup>::const_iterator sg = sourceGroups.begin();
|
|
|
|
sg != sourceGroups.end(); ++sg)
|
|
|
|
{
|
2005-07-13 19:21:30 +04:00
|
|
|
this->WriteGroup(&(*sg), target, fout, libName);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Write the DSP file's footer.
|
|
|
|
this->WriteDSPFooter(fout);
|
|
|
|
}
|
|
|
|
|
2006-05-12 19:56:09 +04:00
|
|
|
void cmLocalVisualStudio6Generator
|
|
|
|
::WriteGroup(const cmSourceGroup *sg, cmTarget target,
|
|
|
|
std::ostream &fout, const char *libName)
|
2005-07-13 19:21:30 +04:00
|
|
|
{
|
|
|
|
const std::vector<const cmSourceFile *> &sourceFiles =
|
|
|
|
sg->GetSourceFiles();
|
|
|
|
// If the group is empty, don't write it at all.
|
|
|
|
|
|
|
|
if(sourceFiles.empty())
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the group has a name, write the header.
|
|
|
|
std::string name = sg->GetName();
|
|
|
|
if(name != "")
|
|
|
|
{
|
|
|
|
this->WriteDSPBeginGroup(fout, name.c_str(), "");
|
|
|
|
}
|
2002-09-04 23:23:56 +04:00
|
|
|
|
2005-07-13 19:21:30 +04:00
|
|
|
// Loop through each source in the source group.
|
|
|
|
for(std::vector<const cmSourceFile *>::const_iterator sf =
|
|
|
|
sourceFiles.begin(); sf != sourceFiles.end(); ++sf)
|
|
|
|
{
|
|
|
|
std::string source = (*sf)->GetFullPath();
|
|
|
|
const cmCustomCommand *command =
|
|
|
|
(*sf)->GetCustomCommand();
|
|
|
|
std::string compileFlags;
|
|
|
|
std::vector<std::string> depends;
|
2006-02-20 22:21:10 +03:00
|
|
|
|
|
|
|
// Add per-source file flags.
|
|
|
|
if(const char* cflags = (*sf)->GetProperty("COMPILE_FLAGS"))
|
2006-01-25 16:38:06 +03:00
|
|
|
{
|
2006-02-20 22:21:10 +03:00
|
|
|
compileFlags += cflags;
|
2006-01-25 16:38:06 +03:00
|
|
|
}
|
|
|
|
|
2006-05-12 19:56:09 +04:00
|
|
|
const char* lang = this->GlobalGenerator->
|
|
|
|
GetLanguageFromExtension((*sf)->GetSourceExtension().c_str());
|
2005-07-13 19:21:30 +04:00
|
|
|
if(lang && strcmp(lang, "CXX") == 0)
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2005-07-13 19:21:30 +04:00
|
|
|
// force a C++ file type
|
|
|
|
compileFlags += " /TP ";
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check for extra object-file dependencies.
|
|
|
|
const char* dependsValue = (*sf)->GetProperty("OBJECT_DEPENDS");
|
|
|
|
if(dependsValue)
|
|
|
|
{
|
|
|
|
cmSystemTools::ExpandListArgument(dependsValue, depends);
|
|
|
|
}
|
2006-02-25 01:35:35 +03:00
|
|
|
if (source != libName || target.GetType() == cmTarget::UTILITY ||
|
|
|
|
target.GetType() == cmTarget::GLOBAL_TARGET)
|
2005-07-13 19:21:30 +04:00
|
|
|
{
|
|
|
|
fout << "# Begin Source File\n\n";
|
|
|
|
|
|
|
|
// Tell MS-Dev what the source is. If the compiler knows how to
|
|
|
|
// build it, then it will.
|
|
|
|
fout << "SOURCE=" <<
|
|
|
|
this->ConvertToOptionallyRelativeOutputPath(source.c_str()) << "\n\n";
|
|
|
|
if(!depends.empty())
|
2003-06-03 18:30:23 +04:00
|
|
|
{
|
2005-07-13 19:21:30 +04:00
|
|
|
// Write out the dependencies for the rule.
|
|
|
|
fout << "USERDEP__HACK=";
|
|
|
|
for(std::vector<std::string>::const_iterator d = depends.begin();
|
|
|
|
d != depends.end(); ++d)
|
|
|
|
{
|
|
|
|
fout << "\\\n\t" <<
|
|
|
|
this->ConvertToOptionallyRelativeOutputPath(d->c_str());
|
|
|
|
}
|
|
|
|
fout << "\n";
|
2003-06-03 18:30:23 +04:00
|
|
|
}
|
2005-07-13 19:21:30 +04:00
|
|
|
if (command)
|
2003-06-03 18:30:23 +04:00
|
|
|
{
|
2005-07-13 19:21:30 +04:00
|
|
|
std::string script =
|
2006-02-08 18:58:36 +03:00
|
|
|
this->ConstructScript(command->GetCommandLines(),
|
|
|
|
command->GetWorkingDirectory(),
|
|
|
|
"\\\n\t");
|
2006-04-11 19:06:19 +04:00
|
|
|
std::string comment =
|
|
|
|
this->ConstructComment(*command,
|
|
|
|
"Building Custom Rule $(InputPath)");
|
|
|
|
if(comment == "<hack>")
|
|
|
|
{
|
|
|
|
comment = "";
|
|
|
|
}
|
2005-07-13 19:21:30 +04:00
|
|
|
const char* flags = compileFlags.size() ? compileFlags.c_str(): 0;
|
2006-04-11 19:06:19 +04:00
|
|
|
this->WriteCustomRule(fout, source.c_str(), script.c_str(),
|
|
|
|
comment.c_str(), command->GetDepends(),
|
|
|
|
command->GetOutputs(), flags);
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
2005-07-13 19:21:30 +04:00
|
|
|
else if(compileFlags.size())
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2005-07-13 19:21:30 +04:00
|
|
|
for(std::vector<std::string>::iterator i
|
2006-05-12 19:56:09 +04:00
|
|
|
= this->Configurations.begin();
|
|
|
|
i != this->Configurations.end(); ++i)
|
2005-07-13 19:21:30 +04:00
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
if (i == this->Configurations.begin())
|
2005-07-13 19:21:30 +04:00
|
|
|
{
|
|
|
|
fout << "!IF \"$(CFG)\" == " << i->c_str() << std::endl;
|
2002-12-14 00:16:48 +03:00
|
|
|
}
|
2005-07-13 19:21:30 +04:00
|
|
|
else
|
|
|
|
{
|
|
|
|
fout << "!ELSEIF \"$(CFG)\" == " << i->c_str() << std::endl;
|
|
|
|
}
|
|
|
|
fout << "\n# ADD CPP " << compileFlags << "\n\n";
|
|
|
|
}
|
|
|
|
fout << "!ENDIF\n\n";
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
2005-07-13 19:21:30 +04:00
|
|
|
fout << "# End Source File\n";
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
2005-07-13 19:21:30 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<cmSourceGroup> children = sg->GetGroupChildren();
|
|
|
|
|
|
|
|
for(unsigned int i=0;i<children.size();++i)
|
|
|
|
{
|
|
|
|
this->WriteGroup(&children[i], target, fout, libName);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2002-09-04 23:23:56 +04:00
|
|
|
|
2005-07-13 19:21:30 +04:00
|
|
|
// If the group has a name, write the footer.
|
|
|
|
if(name != "")
|
|
|
|
{
|
|
|
|
this->WriteDSPEndGroup(fout);
|
|
|
|
}
|
2002-09-04 23:23:56 +04:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-26 19:08:18 +04:00
|
|
|
void
|
|
|
|
cmLocalVisualStudio6Generator
|
|
|
|
::AddUtilityCommandHack(cmTarget& target, int count,
|
|
|
|
std::vector<std::string>& depends,
|
2006-02-08 20:01:21 +03:00
|
|
|
const cmCustomCommand& origCommand)
|
2005-04-26 19:08:18 +04:00
|
|
|
{
|
|
|
|
// Create a fake output that forces the rule to run.
|
2006-03-15 19:02:08 +03:00
|
|
|
char* output = new char[(strlen(this->Makefile->GetStartOutputDirectory()) +
|
2005-04-26 19:08:18 +04:00
|
|
|
strlen(target.GetName()) + 30)];
|
2006-03-15 19:02:08 +03:00
|
|
|
sprintf(output,"%s/%s_force_%i", this->Makefile->GetStartOutputDirectory(),
|
2005-04-26 19:08:18 +04:00
|
|
|
target.GetName(), count);
|
2006-04-11 19:06:19 +04:00
|
|
|
std::string comment = this->ConstructComment(origCommand, "<hack>");
|
2005-04-26 19:08:18 +04:00
|
|
|
|
|
|
|
// Add the rule with the given dependencies and commands.
|
|
|
|
const char* no_main_dependency = 0;
|
2006-03-15 19:02:08 +03:00
|
|
|
this->Makefile->AddCustomCommandToOutput(output,
|
2005-04-26 19:08:18 +04:00
|
|
|
depends,
|
|
|
|
no_main_dependency,
|
2006-02-08 20:01:21 +03:00
|
|
|
origCommand.GetCommandLines(),
|
2006-04-11 19:06:19 +04:00
|
|
|
comment.c_str(),
|
2006-02-08 20:01:21 +03:00
|
|
|
origCommand.GetWorkingDirectory());
|
2005-04-26 19:08:18 +04:00
|
|
|
|
|
|
|
// Replace the dependencies with the output of this rule so that the
|
|
|
|
// next rule added will run after this one.
|
|
|
|
depends.clear();
|
|
|
|
depends.push_back(output);
|
|
|
|
|
|
|
|
// Add a source file representing this output to the project.
|
2006-03-15 19:02:08 +03:00
|
|
|
cmSourceFile* outsf = this->Makefile->GetSourceFileWithOutput(output);
|
2005-04-26 19:08:18 +04:00
|
|
|
target.GetSourceFiles().push_back(outsf);
|
|
|
|
|
|
|
|
// Free the fake output name.
|
|
|
|
delete [] output;
|
|
|
|
}
|
|
|
|
|
2006-04-11 19:06:19 +04:00
|
|
|
void
|
|
|
|
cmLocalVisualStudio6Generator
|
|
|
|
::WriteCustomRule(std::ostream& fout,
|
|
|
|
const char* source,
|
|
|
|
const char* command,
|
|
|
|
const char* comment,
|
|
|
|
const std::vector<std::string>& depends,
|
|
|
|
const std::vector<std::string>& outputs,
|
|
|
|
const char* flags)
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2006-04-11 19:06:19 +04:00
|
|
|
// Write the rule for each configuration.
|
2002-09-04 23:23:56 +04:00
|
|
|
std::vector<std::string>::iterator i;
|
2006-03-15 19:02:08 +03:00
|
|
|
for(i = this->Configurations.begin(); i != this->Configurations.end(); ++i)
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
if (i == this->Configurations.begin())
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
|
|
|
fout << "!IF \"$(CFG)\" == " << i->c_str() << std::endl;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
fout << "!ELSEIF \"$(CFG)\" == " << i->c_str() << std::endl;
|
|
|
|
}
|
|
|
|
if(flags)
|
|
|
|
{
|
|
|
|
fout << "\n# ADD CPP " << flags << "\n\n";
|
|
|
|
}
|
|
|
|
// Write out the dependencies for the rule.
|
|
|
|
fout << "USERDEP__HACK=";
|
2003-06-03 18:30:23 +04:00
|
|
|
for(std::vector<std::string>::const_iterator d = depends.begin();
|
2002-10-24 02:03:27 +04:00
|
|
|
d != depends.end(); ++d)
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2006-01-14 02:18:32 +03:00
|
|
|
// Lookup the real name of the dependency in case it is a CMake target.
|
|
|
|
std::string dep = this->GetRealDependency(d->c_str(), i->c_str());
|
|
|
|
fout << "\\\n\t" <<
|
|
|
|
this->ConvertToOptionallyRelativeOutputPath(dep.c_str());
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
|
|
|
fout << "\n";
|
|
|
|
|
|
|
|
fout << "# PROP Ignore_Default_Tool 1\n";
|
2006-04-11 19:06:19 +04:00
|
|
|
fout << "# Begin Custom Build -";
|
|
|
|
if(comment && *comment)
|
|
|
|
{
|
|
|
|
fout << " " << comment;
|
|
|
|
}
|
|
|
|
fout << "\n\n";
|
|
|
|
if(outputs.empty())
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2006-05-12 19:56:09 +04:00
|
|
|
fout << source
|
|
|
|
<< "_force : \"$(SOURCE)\" \"$(INTDIR)\" \"$(OUTDIR)\"\n\t";
|
2002-09-04 23:23:56 +04:00
|
|
|
fout << command << "\n\n";
|
|
|
|
}
|
2006-04-11 19:06:19 +04:00
|
|
|
else
|
|
|
|
{
|
|
|
|
for(std::vector<std::string>::const_iterator o = outputs.begin();
|
|
|
|
o != outputs.end(); ++o)
|
|
|
|
{
|
|
|
|
// Write a rule for every output generated by this command.
|
|
|
|
fout << this->ConvertToOptionallyRelativeOutputPath(o->c_str())
|
|
|
|
<< " : \"$(SOURCE)\" \"$(INTDIR)\" \"$(OUTDIR)\"\n\t";
|
|
|
|
fout << command << "\n\n";
|
|
|
|
}
|
|
|
|
}
|
2002-09-04 23:23:56 +04:00
|
|
|
fout << "# End Custom Build\n\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
fout << "!ENDIF\n\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void cmLocalVisualStudio6Generator::WriteDSPBeginGroup(std::ostream& fout,
|
2005-07-13 19:21:30 +04:00
|
|
|
const char* group,
|
|
|
|
const char* filter)
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
|
|
|
fout << "# Begin Group \"" << group << "\"\n"
|
|
|
|
"# PROP Default_Filter \"" << filter << "\"\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void cmLocalVisualStudio6Generator::WriteDSPEndGroup(std::ostream& fout)
|
|
|
|
{
|
|
|
|
fout << "# End Group\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2003-02-07 22:04:16 +03:00
|
|
|
void cmLocalVisualStudio6Generator::SetBuildType(BuildType b,
|
|
|
|
const char* libName,
|
2005-06-22 17:06:46 +04:00
|
|
|
cmTarget& target)
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
std::string root= this->Makefile->GetRequiredDefinition("CMAKE_ROOT");
|
2006-05-12 19:56:09 +04:00
|
|
|
const char *def=
|
|
|
|
this->Makefile->GetDefinition( "MSPROJECT_TEMPLATE_DIRECTORY");
|
2002-09-04 23:23:56 +04:00
|
|
|
|
|
|
|
if( def)
|
|
|
|
{
|
|
|
|
root = def;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
root += "/Templates";
|
|
|
|
}
|
|
|
|
|
|
|
|
switch(b)
|
|
|
|
{
|
|
|
|
case STATIC_LIBRARY:
|
2006-03-15 19:02:08 +03:00
|
|
|
this->DSPHeaderTemplate = root;
|
|
|
|
this->DSPHeaderTemplate += "/staticLibHeader.dsptemplate";
|
|
|
|
this->DSPFooterTemplate = root;
|
|
|
|
this->DSPFooterTemplate += "/staticLibFooter.dsptemplate";
|
2002-09-04 23:23:56 +04:00
|
|
|
break;
|
|
|
|
case DLL:
|
2006-03-15 19:02:08 +03:00
|
|
|
this->DSPHeaderTemplate = root;
|
|
|
|
this->DSPHeaderTemplate += "/DLLHeader.dsptemplate";
|
|
|
|
this->DSPFooterTemplate = root;
|
|
|
|
this->DSPFooterTemplate += "/DLLFooter.dsptemplate";
|
2002-09-04 23:23:56 +04:00
|
|
|
break;
|
|
|
|
case EXECUTABLE:
|
2004-02-29 02:59:19 +03:00
|
|
|
if ( target.GetPropertyAsBool("WIN32_EXECUTABLE") )
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
this->DSPHeaderTemplate = root;
|
|
|
|
this->DSPHeaderTemplate += "/EXEWinHeader.dsptemplate";
|
|
|
|
this->DSPFooterTemplate = root;
|
|
|
|
this->DSPFooterTemplate += "/EXEFooter.dsptemplate";
|
2004-02-29 02:59:19 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
this->DSPHeaderTemplate = root;
|
|
|
|
this->DSPHeaderTemplate += "/EXEHeader.dsptemplate";
|
|
|
|
this->DSPFooterTemplate = root;
|
|
|
|
this->DSPFooterTemplate += "/EXEFooter.dsptemplate";
|
2004-02-29 02:59:19 +03:00
|
|
|
}
|
2002-09-04 23:23:56 +04:00
|
|
|
break;
|
|
|
|
case UTILITY:
|
2006-03-15 19:02:08 +03:00
|
|
|
this->DSPHeaderTemplate = root;
|
|
|
|
this->DSPHeaderTemplate += "/UtilityHeader.dsptemplate";
|
|
|
|
this->DSPFooterTemplate = root;
|
|
|
|
this->DSPFooterTemplate += "/UtilityFooter.dsptemplate";
|
2002-09-04 23:23:56 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// once the build type is set, determine what configurations are
|
|
|
|
// possible
|
2006-03-15 19:02:08 +03:00
|
|
|
std::ifstream fin(this->DSPHeaderTemplate.c_str());
|
2002-09-04 23:23:56 +04:00
|
|
|
|
2003-06-23 22:10:12 +04:00
|
|
|
cmsys::RegularExpression reg("# Name ");
|
2002-09-04 23:23:56 +04:00
|
|
|
if(!fin)
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
cmSystemTools::Error("Error Reading ", this->DSPHeaderTemplate.c_str());
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
|
|
|
|
2006-03-15 19:02:08 +03:00
|
|
|
// reset this->Configurations
|
2006-05-12 19:56:09 +04:00
|
|
|
this->Configurations.erase(this->Configurations.begin(),
|
|
|
|
this->Configurations.end());
|
2002-09-04 23:23:56 +04:00
|
|
|
// now add all the configurations possible
|
2003-03-27 20:24:30 +03:00
|
|
|
std::string line;
|
|
|
|
while(cmSystemTools::GetLineFromStream(fin, line))
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
|
|
|
cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME",libName);
|
|
|
|
if (reg.find(line))
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
this->Configurations.push_back(line.substr(reg.end()));
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// look for custom rules on a target and collect them together
|
|
|
|
std::string
|
2005-06-22 17:06:46 +04:00
|
|
|
cmLocalVisualStudio6Generator::CreateTargetRules(cmTarget &target,
|
2003-06-04 16:42:58 +04:00
|
|
|
const char * /* libName */)
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
|
|
|
std::string customRuleCode = "";
|
|
|
|
|
2006-02-25 01:35:35 +03:00
|
|
|
if (target.GetType() >= cmTarget::UTILITY )
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
|
|
|
return customRuleCode;
|
|
|
|
}
|
2003-06-03 18:30:23 +04:00
|
|
|
|
|
|
|
// are there any rules?
|
|
|
|
if (target.GetPreBuildCommands().size() +
|
|
|
|
target.GetPreLinkCommands().size() +
|
|
|
|
target.GetPostBuildCommands().size() == 0)
|
|
|
|
{
|
|
|
|
return customRuleCode;
|
|
|
|
}
|
|
|
|
|
|
|
|
customRuleCode = "# Begin Special Build Tool\n";
|
2005-03-01 18:05:58 +03:00
|
|
|
|
|
|
|
// Write the pre-build and pre-link together (VS6 does not support
|
|
|
|
// both). Make sure no continuation character is put on the last
|
|
|
|
// line.
|
|
|
|
int prelink_total = (static_cast<int>(target.GetPreBuildCommands().size())+
|
|
|
|
static_cast<int>(target.GetPreLinkCommands().size()));
|
|
|
|
int prelink_count = 0;
|
|
|
|
if(prelink_total > 0)
|
|
|
|
{
|
|
|
|
// header stuff
|
|
|
|
customRuleCode += "PreLink_Cmds=";
|
|
|
|
}
|
|
|
|
const char* prelink_newline = "\\\n\t";
|
|
|
|
for (std::vector<cmCustomCommand>::const_iterator cr =
|
|
|
|
target.GetPreBuildCommands().begin();
|
2003-06-03 18:30:23 +04:00
|
|
|
cr != target.GetPreBuildCommands().end(); ++cr)
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2005-03-01 18:05:58 +03:00
|
|
|
if(++prelink_count == prelink_total)
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2005-03-01 18:05:58 +03:00
|
|
|
prelink_newline = "";
|
2003-06-03 18:30:23 +04:00
|
|
|
}
|
2005-03-01 18:05:58 +03:00
|
|
|
customRuleCode += this->ConstructScript(cr->GetCommandLines(),
|
2006-02-08 18:58:36 +03:00
|
|
|
cr->GetWorkingDirectory(),
|
2005-03-01 18:05:58 +03:00
|
|
|
prelink_newline);
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
2005-03-01 18:05:58 +03:00
|
|
|
for (std::vector<cmCustomCommand>::const_iterator cr =
|
|
|
|
target.GetPreLinkCommands().begin();
|
2003-06-03 18:30:23 +04:00
|
|
|
cr != target.GetPreLinkCommands().end(); ++cr)
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2005-03-01 18:05:58 +03:00
|
|
|
if(++prelink_count == prelink_total)
|
2003-06-03 18:30:23 +04:00
|
|
|
{
|
2005-03-01 18:05:58 +03:00
|
|
|
prelink_newline = "";
|
2003-06-03 18:30:23 +04:00
|
|
|
}
|
2005-03-01 18:05:58 +03:00
|
|
|
customRuleCode += this->ConstructScript(cr->GetCommandLines(),
|
2006-02-08 18:58:36 +03:00
|
|
|
cr->GetWorkingDirectory(),
|
2005-03-01 18:05:58 +03:00
|
|
|
prelink_newline);
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
2005-03-01 18:05:58 +03:00
|
|
|
if(prelink_total > 0)
|
2005-03-01 00:11:21 +03:00
|
|
|
{
|
|
|
|
customRuleCode += "\n";
|
|
|
|
}
|
2005-03-01 18:05:58 +03:00
|
|
|
|
|
|
|
// Write the post-build rules. Make sure no continuation character
|
|
|
|
// is put on the last line.
|
2006-05-12 19:56:09 +04:00
|
|
|
int postbuild_total =
|
|
|
|
static_cast<int>(target.GetPostBuildCommands().size());
|
2005-03-01 18:05:58 +03:00
|
|
|
int postbuild_count = 0;
|
|
|
|
const char* postbuild_newline = "\\\n\t";
|
|
|
|
if(postbuild_total > 0)
|
|
|
|
{
|
|
|
|
customRuleCode += "PostBuild_Cmds=";
|
|
|
|
}
|
|
|
|
for (std::vector<cmCustomCommand>::const_iterator cr =
|
|
|
|
target.GetPostBuildCommands().begin();
|
2003-06-03 18:30:23 +04:00
|
|
|
cr != target.GetPostBuildCommands().end(); ++cr)
|
|
|
|
{
|
2005-03-01 18:05:58 +03:00
|
|
|
if(++postbuild_count == postbuild_total)
|
2003-06-03 18:30:23 +04:00
|
|
|
{
|
2005-03-01 18:05:58 +03:00
|
|
|
postbuild_newline = "";
|
2003-06-03 18:30:23 +04:00
|
|
|
}
|
2005-03-01 18:05:58 +03:00
|
|
|
customRuleCode += this->ConstructScript(cr->GetCommandLines(),
|
2006-02-08 18:58:36 +03:00
|
|
|
cr->GetWorkingDirectory(),
|
2005-03-01 18:05:58 +03:00
|
|
|
postbuild_newline);
|
|
|
|
}
|
|
|
|
if(postbuild_total > 0)
|
|
|
|
{
|
|
|
|
customRuleCode += "\n";
|
2003-06-03 18:30:23 +04:00
|
|
|
}
|
|
|
|
|
2005-03-01 18:05:58 +03:00
|
|
|
customRuleCode += "# End Special Build Tool\n";
|
2002-09-04 23:23:56 +04:00
|
|
|
return customRuleCode;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
inline std::string removeQuotes(const std::string& s)
|
|
|
|
{
|
|
|
|
if(s[0] == '\"' && s[s.size()-1] == '\"')
|
|
|
|
{
|
|
|
|
return s.substr(1, s.size()-2);
|
|
|
|
}
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2006-04-19 18:34:41 +04:00
|
|
|
// Code in blocks surrounded by a test for this definition is needed
|
|
|
|
// only for compatibility with user project's replacement DSP
|
|
|
|
// templates. The CMake templates no longer use them.
|
|
|
|
#define CM_USE_OLD_VS6
|
|
|
|
|
2005-06-16 19:48:43 +04:00
|
|
|
void cmLocalVisualStudio6Generator
|
|
|
|
::WriteDSPHeader(std::ostream& fout,
|
2005-06-22 17:06:46 +04:00
|
|
|
const char *libName, cmTarget &target,
|
2005-06-16 19:48:43 +04:00
|
|
|
std::vector<cmSourceGroup> &)
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2006-04-19 18:34:41 +04:00
|
|
|
// Lookup the library and executable output directories.
|
|
|
|
std::string libPath;
|
|
|
|
if(this->Makefile->GetDefinition("LIBRARY_OUTPUT_PATH"))
|
|
|
|
{
|
|
|
|
libPath = this->Makefile->GetDefinition("LIBRARY_OUTPUT_PATH");
|
|
|
|
}
|
|
|
|
std::string exePath;
|
|
|
|
if(this->Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH"))
|
|
|
|
{
|
|
|
|
exePath = this->Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure there are trailing slashes.
|
|
|
|
if(!libPath.empty())
|
|
|
|
{
|
|
|
|
if(libPath[libPath.size()-1] != '/')
|
|
|
|
{
|
|
|
|
libPath += "/";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(!exePath.empty())
|
|
|
|
{
|
|
|
|
if(exePath[exePath.size()-1] != '/')
|
|
|
|
{
|
|
|
|
exePath += "/";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CM_USE_OLD_VS6
|
2002-09-04 23:23:56 +04:00
|
|
|
std::set<std::string> pathEmitted;
|
|
|
|
|
|
|
|
// determine the link directories
|
|
|
|
std::string libOptions;
|
|
|
|
std::string libDebugOptions;
|
|
|
|
std::string libOptimizedOptions;
|
|
|
|
|
|
|
|
std::string libMultiLineOptions;
|
2003-11-01 00:55:49 +03:00
|
|
|
std::string libMultiLineOptionsForDebug;
|
2002-09-04 23:23:56 +04:00
|
|
|
std::string libMultiLineDebugOptions;
|
|
|
|
std::string libMultiLineOptimizedOptions;
|
|
|
|
|
|
|
|
if(libPath.size())
|
|
|
|
{
|
|
|
|
std::string lpath =
|
2005-02-25 02:35:36 +03:00
|
|
|
this->ConvertToOptionallyRelativeOutputPath(libPath.c_str());
|
2003-12-23 00:21:27 +03:00
|
|
|
if(lpath.size() == 0)
|
|
|
|
{
|
|
|
|
lpath = ".";
|
|
|
|
}
|
2002-09-04 23:23:56 +04:00
|
|
|
std::string lpathIntDir = libPath + "$(INTDIR)";
|
2006-05-12 19:56:09 +04:00
|
|
|
lpathIntDir =
|
|
|
|
this->ConvertToOptionallyRelativeOutputPath(lpathIntDir.c_str());
|
2002-09-04 23:23:56 +04:00
|
|
|
if(pathEmitted.insert(lpath).second)
|
|
|
|
{
|
|
|
|
libOptions += " /LIBPATH:";
|
|
|
|
libOptions += lpathIntDir;
|
|
|
|
libOptions += " ";
|
|
|
|
libOptions += " /LIBPATH:";
|
|
|
|
libOptions += lpath;
|
|
|
|
libOptions += " ";
|
|
|
|
libMultiLineOptions += "# ADD LINK32 /LIBPATH:";
|
|
|
|
libMultiLineOptions += lpathIntDir;
|
|
|
|
libMultiLineOptions += " ";
|
|
|
|
libMultiLineOptions += " /LIBPATH:";
|
|
|
|
libMultiLineOptions += lpath;
|
|
|
|
libMultiLineOptions += " \n";
|
2003-11-01 00:55:49 +03:00
|
|
|
libMultiLineOptionsForDebug += "# ADD LINK32 /LIBPATH:";
|
|
|
|
libMultiLineOptionsForDebug += lpathIntDir;
|
|
|
|
libMultiLineOptionsForDebug += " ";
|
|
|
|
libMultiLineOptionsForDebug += " /LIBPATH:";
|
|
|
|
libMultiLineOptionsForDebug += lpath;
|
|
|
|
libMultiLineOptionsForDebug += " \n";
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if(exePath.size())
|
|
|
|
{
|
|
|
|
std::string lpath =
|
2005-02-25 02:35:36 +03:00
|
|
|
this->ConvertToOptionallyRelativeOutputPath(exePath.c_str());
|
2003-12-23 00:21:27 +03:00
|
|
|
if(lpath.size() == 0)
|
|
|
|
{
|
|
|
|
lpath = ".";
|
|
|
|
}
|
2002-09-04 23:23:56 +04:00
|
|
|
std::string lpathIntDir = exePath + "$(INTDIR)";
|
2006-05-12 19:56:09 +04:00
|
|
|
lpathIntDir =
|
|
|
|
this->ConvertToOptionallyRelativeOutputPath(lpathIntDir.c_str());
|
2002-09-04 23:23:56 +04:00
|
|
|
|
|
|
|
if(pathEmitted.insert(lpath).second)
|
|
|
|
{
|
|
|
|
libOptions += " /LIBPATH:";
|
|
|
|
libOptions += lpathIntDir;
|
|
|
|
libOptions += " ";
|
|
|
|
libOptions += " /LIBPATH:";
|
|
|
|
libOptions += lpath;
|
|
|
|
libOptions += " ";
|
|
|
|
libMultiLineOptions += "# ADD LINK32 /LIBPATH:";
|
|
|
|
libMultiLineOptions += lpathIntDir;
|
|
|
|
libMultiLineOptions += " ";
|
|
|
|
libMultiLineOptions += " /LIBPATH:";
|
|
|
|
libMultiLineOptions += lpath;
|
|
|
|
libMultiLineOptions += " \n";
|
2003-11-01 00:55:49 +03:00
|
|
|
libMultiLineOptionsForDebug += "# ADD LINK32 /LIBPATH:";
|
|
|
|
libMultiLineOptionsForDebug += lpathIntDir;
|
|
|
|
libMultiLineOptionsForDebug += " ";
|
|
|
|
libMultiLineOptionsForDebug += " /LIBPATH:";
|
|
|
|
libMultiLineOptionsForDebug += lpath;
|
|
|
|
libMultiLineOptionsForDebug += " \n";
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
std::vector<std::string>::const_iterator i;
|
|
|
|
const std::vector<std::string>& libdirs = target.GetLinkDirectories();
|
|
|
|
for(i = libdirs.begin(); i != libdirs.end(); ++i)
|
|
|
|
{
|
|
|
|
std::string path = *i;
|
|
|
|
if(path[path.size()-1] != '/')
|
|
|
|
{
|
|
|
|
path += "/";
|
|
|
|
}
|
|
|
|
std::string lpath =
|
2005-02-25 02:35:36 +03:00
|
|
|
this->ConvertToOptionallyRelativeOutputPath(path.c_str());
|
2003-12-23 00:21:27 +03:00
|
|
|
if(lpath.size() == 0)
|
|
|
|
{
|
|
|
|
lpath = ".";
|
|
|
|
}
|
2002-09-04 23:23:56 +04:00
|
|
|
std::string lpathIntDir = path + "$(INTDIR)";
|
2006-05-12 19:56:09 +04:00
|
|
|
lpathIntDir =
|
|
|
|
this->ConvertToOptionallyRelativeOutputPath(lpathIntDir.c_str());
|
2002-09-04 23:23:56 +04:00
|
|
|
if(pathEmitted.insert(lpath).second)
|
|
|
|
{
|
|
|
|
libOptions += " /LIBPATH:";
|
|
|
|
libOptions += lpathIntDir;
|
|
|
|
libOptions += " ";
|
|
|
|
libOptions += " /LIBPATH:";
|
|
|
|
libOptions += lpath;
|
|
|
|
libOptions += " ";
|
|
|
|
|
|
|
|
libMultiLineOptions += "# ADD LINK32 /LIBPATH:";
|
|
|
|
libMultiLineOptions += lpathIntDir;
|
|
|
|
libMultiLineOptions += " ";
|
|
|
|
libMultiLineOptions += " /LIBPATH:";
|
|
|
|
libMultiLineOptions += lpath;
|
|
|
|
libMultiLineOptions += " \n";
|
2003-11-01 00:55:49 +03:00
|
|
|
libMultiLineOptionsForDebug += "# ADD LINK32 /LIBPATH:";
|
|
|
|
libMultiLineOptionsForDebug += lpathIntDir;
|
|
|
|
libMultiLineOptionsForDebug += " ";
|
|
|
|
libMultiLineOptionsForDebug += " /LIBPATH:";
|
|
|
|
libMultiLineOptionsForDebug += lpath;
|
|
|
|
libMultiLineOptionsForDebug += " \n";
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// find link libraries
|
2006-03-15 19:02:08 +03:00
|
|
|
const cmTarget::LinkLibraryVectorType& libs = target.GetLinkLibraries();
|
|
|
|
cmTarget::LinkLibraryVectorType::const_iterator j;
|
2002-09-04 23:23:56 +04:00
|
|
|
for(j = libs.begin(); j != libs.end(); ++j)
|
|
|
|
{
|
|
|
|
// add libraries to executables and dlls (but never include
|
|
|
|
// a library in a library, bad recursion)
|
2006-01-14 02:18:32 +03:00
|
|
|
// NEVER LINK STATIC LIBRARIES TO OTHER STATIC LIBRARIES
|
2002-09-04 23:23:56 +04:00
|
|
|
if ((target.GetType() != cmTarget::SHARED_LIBRARY
|
2002-12-17 20:56:04 +03:00
|
|
|
&& target.GetType() != cmTarget::STATIC_LIBRARY
|
|
|
|
&& target.GetType() != cmTarget::MODULE_LIBRARY) ||
|
|
|
|
(target.GetType()==cmTarget::SHARED_LIBRARY && libName != j->first) ||
|
|
|
|
(target.GetType()==cmTarget::MODULE_LIBRARY && libName != j->first))
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2006-01-14 02:18:32 +03:00
|
|
|
// Compute the proper name to use to link this library.
|
|
|
|
std::string lib;
|
|
|
|
std::string libDebug;
|
2006-03-15 19:02:08 +03:00
|
|
|
cmTarget* tgt = this->GlobalGenerator->FindTarget(0, j->first.c_str());
|
2006-01-14 02:18:32 +03:00
|
|
|
if(tgt)
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2006-05-12 19:56:09 +04:00
|
|
|
lib = cmSystemTools::GetFilenameWithoutExtension
|
|
|
|
(tgt->GetFullName().c_str());
|
|
|
|
libDebug = cmSystemTools::GetFilenameWithoutExtension
|
|
|
|
(tgt->GetFullName("Debug").c_str());
|
2002-09-04 23:23:56 +04:00
|
|
|
lib += ".lib";
|
2003-11-01 00:55:49 +03:00
|
|
|
libDebug += ".lib";
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
2006-01-14 02:18:32 +03:00
|
|
|
else
|
|
|
|
{
|
|
|
|
lib = j->first.c_str();
|
|
|
|
libDebug = j->first.c_str();
|
|
|
|
if(j->first.find(".lib") == std::string::npos)
|
|
|
|
{
|
|
|
|
lib += ".lib";
|
|
|
|
libDebug += ".lib";
|
|
|
|
}
|
|
|
|
}
|
2005-02-25 02:35:36 +03:00
|
|
|
lib = this->ConvertToOptionallyRelativeOutputPath(lib.c_str());
|
2006-05-12 19:56:09 +04:00
|
|
|
libDebug =
|
|
|
|
this->ConvertToOptionallyRelativeOutputPath(libDebug.c_str());
|
2006-01-14 02:18:32 +03:00
|
|
|
|
2002-09-04 23:23:56 +04:00
|
|
|
if (j->second == cmTarget::GENERAL)
|
|
|
|
{
|
|
|
|
libOptions += " ";
|
|
|
|
libOptions += lib;
|
|
|
|
libMultiLineOptions += "# ADD LINK32 ";
|
|
|
|
libMultiLineOptions += lib;
|
|
|
|
libMultiLineOptions += "\n";
|
2003-11-01 00:55:49 +03:00
|
|
|
libMultiLineOptionsForDebug += "# ADD LINK32 ";
|
|
|
|
libMultiLineOptionsForDebug += libDebug;
|
|
|
|
libMultiLineOptionsForDebug += "\n";
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
|
|
|
if (j->second == cmTarget::DEBUG)
|
|
|
|
{
|
|
|
|
libDebugOptions += " ";
|
|
|
|
libDebugOptions += lib;
|
|
|
|
|
|
|
|
libMultiLineDebugOptions += "# ADD LINK32 ";
|
2003-11-01 00:55:49 +03:00
|
|
|
libMultiLineDebugOptions += libDebug;
|
2002-09-04 23:23:56 +04:00
|
|
|
libMultiLineDebugOptions += "\n";
|
|
|
|
}
|
|
|
|
if (j->second == cmTarget::OPTIMIZED)
|
|
|
|
{
|
|
|
|
libOptimizedOptions += " ";
|
|
|
|
libOptimizedOptions += lib;
|
|
|
|
|
|
|
|
libMultiLineOptimizedOptions += "# ADD LINK32 ";
|
|
|
|
libMultiLineOptimizedOptions += lib;
|
|
|
|
libMultiLineOptimizedOptions += "\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-04-19 18:34:41 +04:00
|
|
|
#endif
|
2006-04-18 19:45:31 +04:00
|
|
|
|
|
|
|
// Get extra linker options for this target type.
|
2002-12-05 21:44:11 +03:00
|
|
|
std::string extraLinkOptions;
|
|
|
|
if(target.GetType() == cmTarget::EXECUTABLE)
|
|
|
|
{
|
2006-05-12 19:56:09 +04:00
|
|
|
extraLinkOptions =
|
|
|
|
this->Makefile->GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS");
|
2002-12-05 21:44:11 +03:00
|
|
|
}
|
|
|
|
if(target.GetType() == cmTarget::SHARED_LIBRARY)
|
|
|
|
{
|
2006-05-12 19:56:09 +04:00
|
|
|
extraLinkOptions =
|
|
|
|
this->Makefile->GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS");
|
2002-12-05 21:44:11 +03:00
|
|
|
}
|
2003-05-05 18:23:25 +04:00
|
|
|
if(target.GetType() == cmTarget::MODULE_LIBRARY)
|
|
|
|
{
|
2006-05-12 19:56:09 +04:00
|
|
|
extraLinkOptions =
|
|
|
|
this->Makefile->GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS");
|
2003-05-05 18:23:25 +04:00
|
|
|
}
|
2002-12-05 21:44:11 +03:00
|
|
|
|
2006-04-19 18:34:41 +04:00
|
|
|
// Get extra linker options for this target.
|
|
|
|
if(const char* targetLinkFlags = target.GetProperty("LINK_FLAGS"))
|
2006-04-18 19:45:31 +04:00
|
|
|
{
|
2006-04-19 18:34:41 +04:00
|
|
|
extraLinkOptions += " ";
|
|
|
|
extraLinkOptions += targetLinkFlags;
|
2006-04-18 19:45:31 +04:00
|
|
|
}
|
|
|
|
|
2006-04-19 18:34:41 +04:00
|
|
|
// Get standard libraries for this language.
|
2006-04-12 00:55:49 +04:00
|
|
|
if(target.GetType() >= cmTarget::EXECUTABLE &&
|
|
|
|
target.GetType() <= cmTarget::MODULE_LIBRARY)
|
2004-04-24 00:26:21 +04:00
|
|
|
{
|
2006-04-12 00:55:49 +04:00
|
|
|
// Get the language to use for linking.
|
2006-05-12 19:56:09 +04:00
|
|
|
const char* linkLanguage =
|
|
|
|
target.GetLinkerLanguage(this->GetGlobalGenerator());
|
2006-04-12 00:55:49 +04:00
|
|
|
if(!linkLanguage)
|
|
|
|
{
|
2006-05-12 19:56:09 +04:00
|
|
|
cmSystemTools::Error
|
|
|
|
("CMake can not determine linker language for target:",
|
|
|
|
target.GetName());
|
2006-04-12 00:55:49 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Compute the variable name to lookup standard libraries for this
|
|
|
|
// language.
|
|
|
|
std::string standardLibsVar = "CMAKE_";
|
|
|
|
standardLibsVar += linkLanguage;
|
|
|
|
standardLibsVar += "_STANDARD_LIBRARIES";
|
|
|
|
|
|
|
|
// Add standard libraries.
|
|
|
|
if(const char* stdLibs =
|
|
|
|
this->Makefile->GetDefinition(standardLibsVar.c_str()))
|
|
|
|
{
|
2006-04-19 18:34:41 +04:00
|
|
|
extraLinkOptions += " ";
|
|
|
|
extraLinkOptions += stdLibs;
|
2006-04-12 00:55:49 +04:00
|
|
|
}
|
2004-04-24 00:26:21 +04:00
|
|
|
}
|
2006-04-19 18:34:41 +04:00
|
|
|
|
|
|
|
// Compute the real name of the target.
|
2006-05-12 19:56:09 +04:00
|
|
|
std::string outputName =
|
|
|
|
"(OUTPUT_NAME is for libraries and executables only)";
|
2006-04-19 18:34:41 +04:00
|
|
|
std::string outputNameDebug = outputName;
|
|
|
|
std::string outputNameRelease = outputName;
|
|
|
|
std::string outputNameMinSizeRel = outputName;
|
|
|
|
std::string outputNameRelWithDebInfo = outputName;
|
|
|
|
if(target.GetType() == cmTarget::EXECUTABLE ||
|
|
|
|
target.GetType() == cmTarget::STATIC_LIBRARY ||
|
|
|
|
target.GetType() == cmTarget::SHARED_LIBRARY ||
|
|
|
|
target.GetType() == cmTarget::MODULE_LIBRARY)
|
|
|
|
{
|
|
|
|
outputName = target.GetFullName();
|
|
|
|
outputNameDebug = target.GetFullName("Debug");
|
|
|
|
outputNameRelease = target.GetFullName("Release");
|
|
|
|
outputNameMinSizeRel = target.GetFullName("MinSizeRel");
|
|
|
|
outputNameRelWithDebInfo = target.GetFullName("RelWithDebInfo");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Compute the proper link information for the target.
|
|
|
|
std::string optionsDebug;
|
|
|
|
std::string optionsRelease;
|
|
|
|
std::string optionsMinSizeRel;
|
|
|
|
std::string optionsRelWithDebInfo;
|
|
|
|
if(target.GetType() == cmTarget::EXECUTABLE ||
|
|
|
|
target.GetType() == cmTarget::SHARED_LIBRARY ||
|
|
|
|
target.GetType() == cmTarget::MODULE_LIBRARY)
|
|
|
|
{
|
|
|
|
this->ComputeLinkOptions(target, "Debug", extraLinkOptions,
|
|
|
|
optionsDebug);
|
|
|
|
this->ComputeLinkOptions(target, "Release", extraLinkOptions,
|
|
|
|
optionsRelease);
|
|
|
|
this->ComputeLinkOptions(target, "MinSizeRel", extraLinkOptions,
|
|
|
|
optionsMinSizeRel);
|
|
|
|
this->ComputeLinkOptions(target, "RelWithDebInfo", extraLinkOptions,
|
|
|
|
optionsRelWithDebInfo);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CM_USE_OLD_VS6
|
|
|
|
// Compute link information for the target.
|
|
|
|
if(extraLinkOptions.size())
|
2003-02-07 22:04:16 +03:00
|
|
|
{
|
|
|
|
libOptions += " ";
|
2006-04-19 18:34:41 +04:00
|
|
|
libOptions += extraLinkOptions;
|
2003-02-07 22:04:16 +03:00
|
|
|
libOptions += " ";
|
|
|
|
libMultiLineOptions += "# ADD LINK32 ";
|
2006-04-19 18:34:41 +04:00
|
|
|
libMultiLineOptions += extraLinkOptions;
|
2003-02-07 22:04:16 +03:00
|
|
|
libMultiLineOptions += " \n";
|
2003-11-01 00:55:49 +03:00
|
|
|
libMultiLineOptionsForDebug += "# ADD LINK32 ";
|
2006-04-19 18:34:41 +04:00
|
|
|
libMultiLineOptionsForDebug += extraLinkOptions;
|
2003-11-01 00:55:49 +03:00
|
|
|
libMultiLineOptionsForDebug += " \n";
|
2003-02-07 22:04:16 +03:00
|
|
|
}
|
2006-04-19 18:34:41 +04:00
|
|
|
#endif
|
|
|
|
|
2002-09-04 23:23:56 +04:00
|
|
|
// are there any custom rules on the target itself
|
|
|
|
// only if the target is a lib or exe
|
|
|
|
std::string customRuleCode = this->CreateTargetRules(target, libName);
|
|
|
|
|
2006-03-15 19:02:08 +03:00
|
|
|
std::ifstream fin(this->DSPHeaderTemplate.c_str());
|
2002-09-04 23:23:56 +04:00
|
|
|
if(!fin)
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
cmSystemTools::Error("Error Reading ", this->DSPHeaderTemplate.c_str());
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
2004-04-23 00:58:04 +04:00
|
|
|
std::string staticLibOptions;
|
|
|
|
if(target.GetType() == cmTarget::STATIC_LIBRARY )
|
|
|
|
{
|
|
|
|
if(const char* libflags = target.GetProperty("STATIC_LIBRARY_FLAGS"))
|
|
|
|
{
|
|
|
|
staticLibOptions = libflags;
|
|
|
|
}
|
|
|
|
}
|
2005-02-11 22:13:58 +03:00
|
|
|
std::string exportSymbol;
|
|
|
|
if (const char* custom_export_name = target.GetProperty("DEFINE_SYMBOL"))
|
|
|
|
{
|
|
|
|
exportSymbol = custom_export_name;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
std::string in = libName;
|
|
|
|
in += "_EXPORTS";
|
|
|
|
exportSymbol = cmSystemTools::MakeCindentifier(in.c_str());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-03-27 20:24:30 +03:00
|
|
|
std::string line;
|
|
|
|
while(cmSystemTools::GetLineFromStream(fin, line))
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
const char* mfcFlag = this->Makefile->GetDefinition("CMAKE_MFC_FLAG");
|
2002-12-11 20:09:52 +03:00
|
|
|
if(!mfcFlag)
|
|
|
|
{
|
|
|
|
mfcFlag = "0";
|
|
|
|
}
|
2005-02-11 22:13:58 +03:00
|
|
|
cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME_EXPORTS",
|
|
|
|
exportSymbol.c_str());
|
2002-12-11 20:09:52 +03:00
|
|
|
cmSystemTools::ReplaceString(line, "CMAKE_CUSTOM_RULE_CODE",
|
|
|
|
customRuleCode.c_str());
|
|
|
|
cmSystemTools::ReplaceString(line, "CMAKE_MFC_FLAG",
|
|
|
|
mfcFlag);
|
2004-04-23 00:58:04 +04:00
|
|
|
if(target.GetType() == cmTarget::STATIC_LIBRARY )
|
|
|
|
{
|
|
|
|
cmSystemTools::ReplaceString(line, "CM_STATIC_LIB_ARGS",
|
|
|
|
staticLibOptions.c_str());
|
2004-04-23 17:12:57 +04:00
|
|
|
}
|
2006-03-15 19:02:08 +03:00
|
|
|
if(this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"))
|
2004-04-23 17:12:57 +04:00
|
|
|
{
|
|
|
|
cmSystemTools::ReplaceString(line, "/nologo", "");
|
2004-04-23 00:58:04 +04:00
|
|
|
}
|
2006-04-19 18:34:41 +04:00
|
|
|
|
|
|
|
#ifdef CM_USE_OLD_VS6
|
2002-12-11 20:09:52 +03:00
|
|
|
cmSystemTools::ReplaceString(line, "CM_LIBRARIES",
|
|
|
|
libOptions.c_str());
|
|
|
|
cmSystemTools::ReplaceString(line, "CM_DEBUG_LIBRARIES",
|
|
|
|
libDebugOptions.c_str());
|
|
|
|
cmSystemTools::ReplaceString(line, "CM_OPTIMIZED_LIBRARIES",
|
|
|
|
libOptimizedOptions.c_str());
|
2003-11-01 00:55:49 +03:00
|
|
|
cmSystemTools::ReplaceString(line, "CM_MULTILINE_LIBRARIES_FOR_DEBUG",
|
|
|
|
libMultiLineOptionsForDebug.c_str());
|
2002-12-11 20:09:52 +03:00
|
|
|
cmSystemTools::ReplaceString(line, "CM_MULTILINE_LIBRARIES",
|
|
|
|
libMultiLineOptions.c_str());
|
|
|
|
cmSystemTools::ReplaceString(line, "CM_MULTILINE_DEBUG_LIBRARIES",
|
|
|
|
libMultiLineDebugOptions.c_str());
|
|
|
|
cmSystemTools::ReplaceString(line, "CM_MULTILINE_OPTIMIZED_LIBRARIES",
|
|
|
|
libMultiLineOptimizedOptions.c_str());
|
2006-04-19 18:34:41 +04:00
|
|
|
#endif
|
2002-12-11 20:09:52 +03:00
|
|
|
|
2006-04-18 19:45:31 +04:00
|
|
|
// Substitute the real output name into the template.
|
2006-05-12 19:56:09 +04:00
|
|
|
cmSystemTools::ReplaceString(line, "OUTPUT_NAME_DEBUG",
|
|
|
|
outputNameDebug.c_str());
|
|
|
|
cmSystemTools::ReplaceString(line, "OUTPUT_NAME_RELEASE",
|
|
|
|
outputNameRelease.c_str());
|
|
|
|
cmSystemTools::ReplaceString(line, "OUTPUT_NAME_MINSIZEREL",
|
|
|
|
outputNameMinSizeRel.c_str());
|
|
|
|
cmSystemTools::ReplaceString(line, "OUTPUT_NAME_RELWITHDEBINFO",
|
|
|
|
outputNameRelWithDebInfo.c_str());
|
2005-08-20 01:57:36 +04:00
|
|
|
cmSystemTools::ReplaceString(line, "OUTPUT_NAME", outputName.c_str());
|
|
|
|
|
2006-04-19 18:34:41 +04:00
|
|
|
// Substitute the proper link information into the template.
|
2006-05-12 19:56:09 +04:00
|
|
|
cmSystemTools::ReplaceString(line, "CM_MULTILINE_OPTIONS_DEBUG",
|
|
|
|
optionsDebug.c_str());
|
|
|
|
cmSystemTools::ReplaceString(line, "CM_MULTILINE_OPTIONS_RELEASE",
|
|
|
|
optionsRelease.c_str());
|
|
|
|
cmSystemTools::ReplaceString(line, "CM_MULTILINE_OPTIONS_MINSIZEREL",
|
|
|
|
optionsMinSizeRel.c_str());
|
|
|
|
cmSystemTools::ReplaceString(line, "CM_MULTILINE_OPTIONS_RELWITHDEBINFO",
|
|
|
|
optionsRelWithDebInfo.c_str());
|
2006-04-19 18:34:41 +04:00
|
|
|
|
2002-12-11 20:09:52 +03:00
|
|
|
cmSystemTools::ReplaceString(line, "BUILD_INCLUDES",
|
2006-03-15 19:02:08 +03:00
|
|
|
this->IncludeOptions.c_str());
|
2002-12-11 20:09:52 +03:00
|
|
|
cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME",libName);
|
|
|
|
// because LIBRARY_OUTPUT_PATH and EXECUTABLE_OUTPUT_PATH
|
|
|
|
// are already quoted in the template file,
|
|
|
|
// we need to remove the quotes here, we still need
|
2005-07-14 00:49:51 +04:00
|
|
|
// to convert to output path for unix to win32 conversion
|
2006-05-12 19:56:09 +04:00
|
|
|
cmSystemTools::ReplaceString
|
|
|
|
(line, "LIBRARY_OUTPUT_PATH",
|
|
|
|
removeQuotes(this->ConvertToOptionallyRelativeOutputPath
|
|
|
|
(libPath.c_str())).c_str());
|
|
|
|
cmSystemTools::ReplaceString
|
|
|
|
(line, "EXECUTABLE_OUTPUT_PATH",
|
|
|
|
removeQuotes(this->ConvertToOptionallyRelativeOutputPath
|
|
|
|
(exePath.c_str())).c_str());
|
2005-07-13 19:21:30 +04:00
|
|
|
|
2002-12-11 20:09:52 +03:00
|
|
|
cmSystemTools::ReplaceString(line,
|
|
|
|
"EXTRA_DEFINES",
|
2006-03-15 19:02:08 +03:00
|
|
|
this->Makefile->GetDefineFlags());
|
2003-11-01 00:55:49 +03:00
|
|
|
const char* debugPostfix
|
2006-03-15 19:02:08 +03:00
|
|
|
= this->Makefile->GetDefinition("CMAKE_DEBUG_POSTFIX");
|
2003-11-01 00:55:49 +03:00
|
|
|
cmSystemTools::ReplaceString(line, "DEBUG_POSTFIX",
|
2005-07-13 19:21:30 +04:00
|
|
|
debugPostfix?debugPostfix:"");
|
2003-01-22 19:44:02 +03:00
|
|
|
// store flags for each configuration
|
2003-01-13 17:30:48 +03:00
|
|
|
std::string flags = " ";
|
|
|
|
std::string flagsRelease = " ";
|
|
|
|
std::string flagsMinSize = " ";
|
|
|
|
std::string flagsDebug = " ";
|
|
|
|
std::string flagsDebugRel = " ";
|
2004-09-24 19:35:16 +04:00
|
|
|
if(target.GetType() >= cmTarget::EXECUTABLE &&
|
|
|
|
target.GetType() <= cmTarget::MODULE_LIBRARY)
|
|
|
|
{
|
2006-05-12 19:56:09 +04:00
|
|
|
const char* linkLanguage =
|
|
|
|
target.GetLinkerLanguage(this->GetGlobalGenerator());
|
2004-10-27 18:53:01 +04:00
|
|
|
if(!linkLanguage)
|
|
|
|
{
|
2006-05-12 19:56:09 +04:00
|
|
|
cmSystemTools::Error
|
|
|
|
("CMake can not determine linker language for target:",
|
|
|
|
target.GetName());
|
2004-10-27 18:53:01 +04:00
|
|
|
return;
|
|
|
|
}
|
2004-09-24 19:35:16 +04:00
|
|
|
// if CXX is on and the target contains cxx code then add the cxx flags
|
|
|
|
std::string baseFlagVar = "CMAKE_";
|
|
|
|
baseFlagVar += linkLanguage;
|
|
|
|
baseFlagVar += "_FLAGS";
|
2006-04-18 19:53:41 +04:00
|
|
|
flags = this->Makefile->GetSafeDefinition(baseFlagVar.c_str());
|
2004-09-24 19:35:16 +04:00
|
|
|
|
|
|
|
std::string flagVar = baseFlagVar + "_RELEASE";
|
2006-04-18 19:53:41 +04:00
|
|
|
flagsRelease = this->Makefile->GetSafeDefinition(flagVar.c_str());
|
2004-09-24 19:35:16 +04:00
|
|
|
flagsRelease += " -DCMAKE_INTDIR=\\\"Release\\\" ";
|
2006-05-12 19:56:09 +04:00
|
|
|
if(const char* targetLinkFlags =
|
|
|
|
target.GetProperty("LINK_FLAGS_RELEASE"))
|
2006-04-03 20:57:51 +04:00
|
|
|
{
|
|
|
|
flagsRelease += targetLinkFlags;
|
|
|
|
flagsRelease += " ";
|
|
|
|
}
|
2004-09-24 19:35:16 +04:00
|
|
|
flagVar = baseFlagVar + "_MINSIZEREL";
|
2006-04-18 19:53:41 +04:00
|
|
|
flagsMinSize = this->Makefile->GetSafeDefinition(flagVar.c_str());
|
2004-09-24 19:35:16 +04:00
|
|
|
flagsMinSize += " -DCMAKE_INTDIR=\\\"MinSizeRel\\\" ";
|
2006-05-12 19:56:09 +04:00
|
|
|
if(const char* targetLinkFlags =
|
|
|
|
target.GetProperty("LINK_FLAGS_MINSIZEREL"))
|
2006-04-03 20:57:51 +04:00
|
|
|
{
|
|
|
|
flagsMinSize += targetLinkFlags;
|
|
|
|
flagsMinSize += " ";
|
|
|
|
}
|
2004-09-24 19:35:16 +04:00
|
|
|
|
|
|
|
flagVar = baseFlagVar + "_DEBUG";
|
2006-04-18 19:53:41 +04:00
|
|
|
flagsDebug = this->Makefile->GetSafeDefinition(flagVar.c_str());
|
2004-09-24 19:35:16 +04:00
|
|
|
flagsDebug += " -DCMAKE_INTDIR=\\\"Debug\\\" ";
|
2006-04-03 20:57:51 +04:00
|
|
|
if(const char* targetLinkFlags = target.GetProperty("LINK_FLAGS_DEBUG"))
|
|
|
|
{
|
|
|
|
flagsDebug += targetLinkFlags;
|
|
|
|
flagsDebug += " ";
|
|
|
|
}
|
|
|
|
|
2004-09-24 19:35:16 +04:00
|
|
|
flagVar = baseFlagVar + "_RELWITHDEBINFO";
|
2006-04-18 19:53:41 +04:00
|
|
|
flagsDebugRel = this->Makefile->GetSafeDefinition(flagVar.c_str());
|
2004-09-24 19:35:16 +04:00
|
|
|
flagsDebugRel += " -DCMAKE_INTDIR=\\\"RelWithDebInfo\\\" ";
|
2006-05-12 19:56:09 +04:00
|
|
|
if(const char* targetLinkFlags =
|
|
|
|
target.GetProperty("LINK_FLAGS_RELWITHDEBINFO"))
|
2006-04-03 20:57:51 +04:00
|
|
|
{
|
|
|
|
flagsDebugRel += targetLinkFlags;
|
|
|
|
flagsDebugRel += " ";
|
|
|
|
}
|
|
|
|
|
2004-09-24 19:35:16 +04:00
|
|
|
}
|
2004-09-22 22:42:05 +04:00
|
|
|
|
2003-10-16 18:32:47 +04:00
|
|
|
// if unicode is not found, then add -D_MBCS
|
2006-03-15 19:02:08 +03:00
|
|
|
std::string defs = this->Makefile->GetDefineFlags();
|
2004-09-17 23:57:01 +04:00
|
|
|
if(flags.find("D_UNICODE") == flags.npos &&
|
|
|
|
defs.find("D_UNICODE") == flags.npos)
|
2003-10-16 18:32:47 +04:00
|
|
|
{
|
|
|
|
flags += " /D \"_MBCS\"";
|
|
|
|
}
|
2006-02-20 22:21:10 +03:00
|
|
|
|
|
|
|
// Add per-target flags.
|
|
|
|
if(const char* targetFlags = target.GetProperty("COMPILE_FLAGS"))
|
|
|
|
{
|
|
|
|
flags += " ";
|
|
|
|
flags += targetFlags;
|
|
|
|
}
|
|
|
|
|
2003-03-14 20:00:22 +03:00
|
|
|
// The template files have CXX FLAGS in them, that need to be replaced.
|
|
|
|
// There are not separate CXX and C template files, so we use the same
|
|
|
|
// variable names. The previous code sets up flags* variables to contain
|
|
|
|
// the correct C or CXX flags
|
2006-05-12 19:56:09 +04:00
|
|
|
cmSystemTools::ReplaceString(line, "CMAKE_CXX_FLAGS_MINSIZEREL",
|
|
|
|
flagsMinSize.c_str());
|
|
|
|
cmSystemTools::ReplaceString(line, "CMAKE_CXX_FLAGS_DEBUG",
|
|
|
|
flagsDebug.c_str());
|
|
|
|
cmSystemTools::ReplaceString(line, "CMAKE_CXX_FLAGS_RELWITHDEBINFO",
|
|
|
|
flagsDebugRel.c_str());
|
|
|
|
cmSystemTools::ReplaceString(line, "CMAKE_CXX_FLAGS_RELEASE",
|
|
|
|
flagsRelease.c_str());
|
2003-01-13 17:30:48 +03:00
|
|
|
cmSystemTools::ReplaceString(line, "CMAKE_CXX_FLAGS", flags.c_str());
|
2002-12-11 20:09:52 +03:00
|
|
|
fout << line.c_str() << std::endl;
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void cmLocalVisualStudio6Generator::WriteDSPFooter(std::ostream& fout)
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
std::ifstream fin(this->DSPFooterTemplate.c_str());
|
2002-09-04 23:23:56 +04:00
|
|
|
if(!fin)
|
|
|
|
{
|
|
|
|
cmSystemTools::Error("Error Reading ",
|
2006-03-15 19:02:08 +03:00
|
|
|
this->DSPFooterTemplate.c_str());
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
2003-03-27 20:24:30 +03:00
|
|
|
std::string line;
|
|
|
|
while(cmSystemTools::GetLineFromStream(fin, line))
|
2002-09-04 23:23:56 +04:00
|
|
|
{
|
2003-03-27 20:24:30 +03:00
|
|
|
fout << line << std::endl;
|
2002-09-04 23:23:56 +04:00
|
|
|
}
|
|
|
|
}
|
2006-04-19 18:34:41 +04:00
|
|
|
|
2006-05-12 19:56:09 +04:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void cmLocalVisualStudio6Generator
|
|
|
|
::ComputeLinkOptions(cmTarget& target,
|
|
|
|
const char* configName,
|
|
|
|
const std::string extraOptions,
|
|
|
|
std::string& options)
|
2006-04-19 18:34:41 +04:00
|
|
|
{
|
|
|
|
// Compute the link information for this configuration.
|
|
|
|
std::vector<cmStdString> linkLibs;
|
|
|
|
std::vector<cmStdString> linkDirs;
|
|
|
|
this->ComputeLinkInformation(target, configName, linkLibs, linkDirs);
|
|
|
|
|
|
|
|
// Build the link options code.
|
|
|
|
for(std::vector<cmStdString>::const_iterator d = linkDirs.begin();
|
|
|
|
d != linkDirs.end(); ++d)
|
|
|
|
{
|
|
|
|
std::string dir = *d;
|
|
|
|
if(!dir.empty())
|
|
|
|
{
|
|
|
|
if(dir[dir.size()-1] != '/')
|
|
|
|
{
|
|
|
|
dir += "/";
|
|
|
|
}
|
|
|
|
dir += "$(IntDir)";
|
|
|
|
options += "# ADD LINK32 /LIBPATH:";
|
|
|
|
options += this->ConvertToOptionallyRelativeOutputPath(dir.c_str());
|
|
|
|
options += " /LIBPATH:";
|
|
|
|
options += this->ConvertToOptionallyRelativeOutputPath(d->c_str());
|
|
|
|
options += "\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for(std::vector<cmStdString>::const_iterator l = linkLibs.begin();
|
|
|
|
l != linkLibs.end(); ++l)
|
|
|
|
{
|
|
|
|
options += "# ADD LINK32 ";
|
|
|
|
options += this->ConvertToOptionallyRelativeOutputPath(l->c_str());
|
|
|
|
options += "\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add extra options if any.
|
|
|
|
if(!extraOptions.empty())
|
|
|
|
{
|
|
|
|
options += "# ADD LINK32 ";
|
|
|
|
options += extraOptions;
|
|
|
|
options += "\n";
|
|
|
|
}
|
|
|
|
}
|