CMake/Source/cmDSPWriter.cxx

758 lines
25 KiB
C++
Raw Normal View History

2001-01-11 22:55:47 +03:00
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile$
Language: C++
Date: $Date$
Version: $Revision$
2001-04-27 16:01:17 +04:00
Copyright (c) 2001 Insight Consortium
All rights reserved.
2001-01-11 22:55:47 +03:00
2001-04-27 16:01:17 +04:00
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
2001-01-11 22:55:47 +03:00
2001-04-27 16:01:17 +04:00
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* The name of the Insight Consortium, nor the names of any consortium members,
nor of any contributors, may be used to endorse or promote products derived
from this software without specific prior written permission.
* Modified source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS''
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2001-01-11 22:55:47 +03:00
=========================================================================*/
#include "cmDSPWriter.h"
#include "cmStandardIncludes.h"
#include "cmSystemTools.h"
2001-02-27 01:17:34 +03:00
#include "cmRegularExpression.h"
2001-02-23 03:24:43 +03:00
cmDSPWriter::~cmDSPWriter()
{
}
cmDSPWriter::cmDSPWriter(cmMakefile*mf)
{
m_Makefile = mf;
}
void cmDSPWriter::OutputDSPFile()
{
2001-02-23 03:24:43 +03:00
// If not an in source build, then create the output directory
if(strcmp(m_Makefile->GetStartOutputDirectory(),
m_Makefile->GetHomeDirectory()) != 0)
{
if(!cmSystemTools::MakeDirectory(m_Makefile->GetStartOutputDirectory()))
{
cmSystemTools::Error("Error creating directory ",
m_Makefile->GetStartOutputDirectory());
}
}
// Setup /I and /LIBPATH options for the resulting DSP file
std::vector<std::string>& includes = m_Makefile->GetIncludeDirectories();
std::vector<std::string>::iterator i;
for(i = includes.begin(); i != includes.end(); ++i)
{
2001-08-29 02:27:02 +04:00
m_IncludeOptions += " /I ";
2001-09-14 23:18:33 +04:00
std::string tmp = cmSystemTools::EscapeSpaces(i->c_str());
cmSystemTools::ConvertToWindowsSlashesAndCleanUp(tmp);
2001-09-11 22:58:57 +04:00
// quote if not already quoted
if (tmp[0] != '"')
{
m_IncludeOptions += "\"";
m_IncludeOptions += tmp;
m_IncludeOptions += "\"";
}
else
{
m_IncludeOptions += tmp;
}
}
2001-02-23 03:24:43 +03:00
// Create the DSP or set of DSP's for libraries and executables
// clear project names
m_CreatedProjectNames.clear();
// build any targets
2001-04-25 00:49:12 +04:00
cmTargets &tgts = m_Makefile->GetTargets();
for(cmTargets::iterator l = tgts.begin();
l != tgts.end(); l++)
{
switch(l->second.GetType())
{
case cmTarget::STATIC_LIBRARY:
this->SetBuildType(STATIC_LIBRARY, l->first.c_str());
break;
case cmTarget::SHARED_LIBRARY:
this->SetBuildType(DLL, l->first.c_str());
break;
case cmTarget::EXECUTABLE:
this->SetBuildType(EXECUTABLE,l->first.c_str());
break;
case cmTarget::WIN32_EXECUTABLE:
this->SetBuildType(WIN32_EXECUTABLE,l->first.c_str());
break;
case cmTarget::UTILITY:
this->SetBuildType(UTILITY, l->first.c_str());
break;
case cmTarget::INSTALL_FILES:
break;
case cmTarget::INSTALL_PROGRAMS:
break;
default:
cmSystemTools::Error("Bad target type", l->first.c_str());
break;
}
2001-10-31 15:03:32 +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)
2001-10-31 15:03:32 +03:00
&& (l->second.GetType() != cmTarget::INSTALL_PROGRAMS)
2001-11-05 13:43:48 +03:00
&& (strncmp(l->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) != 0))
2001-05-23 20:02:47 +04:00
{
this->CreateSingleDSP(l->first.c_str(),l->second);
}
}
}
void cmDSPWriter::CreateSingleDSP(const char *lname, cmTarget &target)
{
std::string fname;
2001-02-15 21:30:13 +03:00
fname = m_Makefile->GetStartOutputDirectory();
fname += "/";
fname += lname;
fname += ".dsp";
std::string pname = lname;
m_CreatedProjectNames.push_back(pname);
std::ofstream fout(fname.c_str());
if(!fout)
{
cmSystemTools::Error("Error Writing ", fname.c_str());
}
2001-04-27 00:22:53 +04:00
this->WriteDSPFile(fout,lname,target);
}
void cmDSPWriter::AddDSPBuildRule(cmSourceGroup& sourceGroup)
{
std::string dspname = *(m_CreatedProjectNames.end()-1);
if(dspname == "ALL_BUILD")
{
return;
}
dspname += ".dsp";
2001-08-28 22:55:14 +04:00
std::string makefileIn = m_Makefile->GetStartDirectory();
makefileIn += "/";
2001-08-28 22:55:14 +04:00
makefileIn += "CMakeLists.txt";
makefileIn = cmSystemTools::HandleNetworkPaths(makefileIn.c_str());
makefileIn = cmSystemTools::EscapeSpaces(makefileIn.c_str());
2001-05-17 20:08:46 +04:00
std::string dsprule = "${CMAKE_COMMAND} ";
2001-08-28 22:55:14 +04:00
m_Makefile->ExpandVariablesInString(dsprule);
dsprule = cmSystemTools::HandleNetworkPaths(dsprule.c_str());
std::string args = makefileIn;
2001-11-22 01:45:01 +03:00
args += " -H\"";
args += cmSystemTools::HandleNetworkPaths(m_Makefile->GetHomeDirectory());
args += "\" -S\"";
args += cmSystemTools::HandleNetworkPaths(m_Makefile->GetStartDirectory());
args += "\" -O\"";
args += cmSystemTools::HandleNetworkPaths(m_Makefile->GetStartOutputDirectory());
args += "\" -B\"";
args += cmSystemTools::HandleNetworkPaths(m_Makefile->GetHomeOutputDirectory());
args += "\"";
m_Makefile->ExpandVariablesInString(args);
2001-04-30 18:52:58 +04:00
std::vector<std::string> outputs;
outputs.push_back(dspname);
cmCustomCommand cc(makefileIn.c_str(), dsprule.c_str(),
args.c_str(),
2001-04-30 18:52:58 +04:00
m_Makefile->GetListFiles(),
outputs);
sourceGroup.AddCustomCommand(cc);
}
void cmDSPWriter::WriteDSPFile(std::ostream& fout,
const char *libName,
2001-04-27 00:22:53 +04:00
cmTarget &target)
{
// We may be modifying the source groups temporarily, so make a copy.
std::vector<cmSourceGroup> sourceGroups = m_Makefile->GetSourceGroups();
// get the classes from the source lists then add them to the groups
2001-04-25 00:49:12 +04:00
std::vector<cmSourceFile> classes = target.GetSourceFiles();
for(std::vector<cmSourceFile>::iterator i = classes.begin();
i != classes.end(); i++)
{
2001-04-25 00:49:12 +04:00
if(!i->IsAHeaderFileOnly())
{
// Add the file to the list of sources.
2001-04-25 00:49:12 +04:00
std::string source = i->GetFullPath();
cmSourceGroup& sourceGroup = m_Makefile->FindSourceGroup(source.c_str(),
sourceGroups);
sourceGroup.AddSource(source.c_str());
}
}
// add any custom rules to the source groups
for (std::vector<cmCustomCommand>::const_iterator cr =
target.GetCustomCommands().begin();
cr != target.GetCustomCommands().end(); ++cr)
{
cmSourceGroup& sourceGroup =
m_Makefile->FindSourceGroup(cr->GetSourceName().c_str(),
sourceGroups);
cmCustomCommand cc(*cr);
cc.ExpandVariables(*m_Makefile);
sourceGroup.AddCustomCommand(cc);
}
// Write the DSP file's header.
this->WriteDSPHeader(fout, libName, target, sourceGroups);
// Find the group in which the CMakeLists.txt source belongs, and add
// the rule to generate this DSP file.
for(std::vector<cmSourceGroup>::reverse_iterator sg = sourceGroups.rbegin();
sg != sourceGroups.rend(); ++sg)
{
if(sg->Matches("CMakeLists.txt"))
{
this->AddDSPBuildRule(*sg);
break;
}
}
// Loop through every source group.
for(std::vector<cmSourceGroup>::const_iterator sg = sourceGroups.begin();
sg != sourceGroups.end(); ++sg)
{
const cmSourceGroup::BuildRules& buildRules = sg->GetBuildRules();
// If the group is empty, don't write it at all.
if(buildRules.empty())
{ continue; }
// If the group has a name, write the header.
std::string name = sg->GetName();
if(name != "")
{
this->WriteDSPBeginGroup(fout, name.c_str(), "");
}
// Loop through each build rule in the source group.
for(cmSourceGroup::BuildRules::const_iterator cc =
buildRules.begin(); cc != buildRules.end(); ++ cc)
{
std::string source = cc->first;
const cmSourceGroup::Commands& commands = cc->second;
2001-11-12 17:21:36 +03:00
if (source != libName || target.GetType() == cmTarget::UTILITY)
{
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=" << cmSystemTools::EscapeSpaces(source.c_str()) << "\n\n";
if (!commands.empty())
2001-05-04 17:39:05 +04:00
{
cmSourceGroup::CommandFiles totalCommand;
std::string totalCommandStr;
totalCommandStr = this->CombineCommands(commands, totalCommand,
source.c_str());
this->WriteCustomRule(fout, source.c_str(), totalCommandStr.c_str(),
totalCommand.m_Depends,
totalCommand.m_Outputs);
2001-05-04 17:39:05 +04:00
}
fout << "# End Source File\n";
2001-05-04 17:39:05 +04:00
}
}
// If the group has a name, write the footer.
if(name != "")
{
this->WriteDSPEndGroup(fout);
}
}
// Write the DSP file's footer.
this->WriteDSPFooter(fout);
}
void cmDSPWriter::WriteCustomRule(std::ostream& fout,
const char* source,
2001-02-27 01:17:34 +03:00
const char* command,
const std::set<std::string>& depends,
const std::set<std::string>& outputs)
{
2001-02-27 01:17:34 +03:00
std::vector<std::string>::iterator i;
for(i = m_Configurations.begin(); i != m_Configurations.end(); ++i)
{
if (i == m_Configurations.begin())
{
fout << "!IF \"$(CFG)\" == " << i->c_str() << std::endl;
}
else
{
fout << "!ELSEIF \"$(CFG)\" == " << i->c_str() << std::endl;
}
// Write out the dependencies for the rule.
fout << "USERDEP__HACK=";
std::string temp;
2001-04-30 18:52:58 +04:00
for(std::set<std::string>::const_iterator d = depends.begin();
d != depends.end(); ++d)
{
temp = *d;
fout << "\\\n\t" << cmSystemTools::EscapeSpaces(cmSystemTools::ConvertToWindowsSlashes(temp));
2001-04-30 18:52:58 +04:00
}
fout << "\n";
fout << "# PROP Ignore_Default_Tool 1\n";
2001-02-27 01:17:34 +03:00
fout << "# Begin Custom Build\n\n";
if(outputs.size() == 0)
{
fout << source << "_force : \"$(SOURCE)\" \"$(INTDIR)\" \"$(OUTDIR)\"";
2001-05-04 17:39:05 +04:00
fout << command << "\n\n";
}
// Write a rule for every output generated by this command.
for(std::set<std::string>::const_iterator output = outputs.begin();
output != outputs.end(); ++output)
2001-02-27 01:17:34 +03:00
{
fout << "\"" << output->c_str()
<< "\" : \"$(SOURCE)\" \"$(INTDIR)\" \"$(OUTDIR)\"";
2001-05-04 17:39:05 +04:00
fout << command << "\n\n";
2001-02-27 01:17:34 +03:00
}
2001-02-27 01:17:34 +03:00
fout << "# End Custom Build\n\n";
}
fout << "!ENDIF\n\n";
}
void cmDSPWriter::WriteDSPBeginGroup(std::ostream& fout,
const char* group,
const char* filter)
{
fout << "# Begin Group \"" << group << "\"\n"
"# PROP Default_Filter \"" << filter << "\"\n";
}
void cmDSPWriter::WriteDSPEndGroup(std::ostream& fout)
{
fout << "# End Group\n";
}
void cmDSPWriter::SetBuildType(BuildType b, const char *libName)
{
std::string root= m_Makefile->GetDefinition("CMAKE_ROOT");
const char *def= m_Makefile->GetDefinition( "MSPROJECT_TEMPLATE_DIRECTORY");
if( def)
{
2001-05-17 20:08:46 +04:00
root = def;
}
else
{
2001-05-17 20:08:46 +04:00
root += "/Templates";
}
2001-05-17 20:08:46 +04:00
switch(b)
{
case STATIC_LIBRARY:
m_DSPHeaderTemplate = root;
m_DSPHeaderTemplate += "/staticLibHeader.dsptemplate";
m_DSPFooterTemplate = root;
m_DSPFooterTemplate += "/staticLibFooter.dsptemplate";
break;
case DLL:
m_DSPHeaderTemplate = root;
m_DSPHeaderTemplate += "/DLLHeader.dsptemplate";
m_DSPFooterTemplate = root;
m_DSPFooterTemplate += "/DLLFooter.dsptemplate";
break;
case EXECUTABLE:
m_DSPHeaderTemplate = root;
m_DSPHeaderTemplate += "/EXEHeader.dsptemplate";
m_DSPFooterTemplate = root;
m_DSPFooterTemplate += "/EXEFooter.dsptemplate";
break;
case WIN32_EXECUTABLE:
m_DSPHeaderTemplate = root;
m_DSPHeaderTemplate += "/EXEWinHeader.dsptemplate";
m_DSPFooterTemplate = root;
m_DSPFooterTemplate += "/EXEFooter.dsptemplate";
break;
case UTILITY:
m_DSPHeaderTemplate = root;
m_DSPHeaderTemplate += "/UtilityHeader.dsptemplate";
m_DSPFooterTemplate = root;
m_DSPFooterTemplate += "/UtilityFooter.dsptemplate";
break;
}
2001-02-27 01:17:34 +03:00
// once the build type is set, determine what configurations are
// possible
std::ifstream fin(m_DSPHeaderTemplate.c_str());
2001-02-27 01:17:34 +03:00
cmRegularExpression reg("# Name ");
if(!fin)
{
cmSystemTools::Error("Error Reading ", m_DSPHeaderTemplate.c_str());
}
// reset m_Configurations
m_Configurations.erase(m_Configurations.begin(), m_Configurations.end());
// now add all the configurations possible
2001-02-27 01:17:34 +03:00
char buffer[2048];
while(fin)
{
fin.getline(buffer, 2048);
std::string line = buffer;
cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME",libName);
2001-02-27 01:17:34 +03:00
if (reg.find(line))
{
m_Configurations.push_back(line.substr(reg.end()));
}
}
}
std::string
cmDSPWriter::CombineCommands(const cmSourceGroup::Commands &commands,
cmSourceGroup::CommandFiles &totalCommand,
const char *source)
{
// Loop through every custom command generating code from the
// current source.
// build up the depends and outputs and commands
std::string totalCommandStr = "";
std::string temp;
for(cmSourceGroup::Commands::const_iterator c = commands.begin();
c != commands.end(); ++c)
{
totalCommandStr += "\n\t";
temp= c->second.m_Command;
cmSystemTools::ConvertToWindowsSlashes(temp);
temp = cmSystemTools::EscapeSpaces(temp.c_str());
totalCommandStr += temp;
totalCommandStr += " ";
totalCommandStr += c->second.m_Arguments;
totalCommand.Merge(c->second);
}
// Create a dummy file with the name of the source if it does
// not exist
if(totalCommand.m_Outputs.empty())
{
std::string dummyFile = m_Makefile->GetStartOutputDirectory();
dummyFile += "/";
dummyFile += source;
if(!cmSystemTools::FileExists(dummyFile.c_str()))
{
std::ofstream fout(dummyFile.c_str());
fout << "Dummy file created by cmake as unused source for utility command.\n";
}
}
return totalCommandStr;
}
// look for custom rules on a target and collect them together
std::string
cmDSPWriter::CreateTargetRules(const cmTarget &target,
const char *libName)
{
std::string customRuleCode = "";
if (target.GetType() >= cmTarget::UTILITY)
{
return customRuleCode;
}
// Find the group in which the lix exe custom rules belong
bool init = false;
for (std::vector<cmCustomCommand>::const_iterator cr =
target.GetCustomCommands().begin();
cr != target.GetCustomCommands().end(); ++cr)
{
cmCustomCommand cc(*cr);
cc.ExpandVariables(*m_Makefile);
if (cc.GetSourceName() == libName)
{
if (!init)
{
// header stuff
customRuleCode = "# Begin Special Build Tool\nPostBuild_Cmds=";
init = true;
}
else
{
customRuleCode += "\t";
}
customRuleCode += cc.GetCommand() + " " + cc.GetArguments();
}
}
if (init)
{
customRuleCode += "\n# End Special Build Tool\n";
}
return customRuleCode;
}
void cmDSPWriter::WriteDSPHeader(std::ostream& fout, const char *libName,
const cmTarget &target,
2001-12-01 01:20:43 +03:00
std::vector<cmSourceGroup> &)
{
2001-04-27 00:22:53 +04:00
// determine the link directories
std::string libOptions;
std::string libDebugOptions;
std::string libOptimizedOptions;
std::string libMultiLineOptions;
std::string libMultiLineDebugOptions;
std::string libMultiLineOptimizedOptions;
2001-05-15 21:14:13 +04:00
// suppoirt override in output directory
std::string libPath = "";
if (m_Makefile->GetDefinition("LIBRARY_OUTPUT_PATH"))
{
libPath = m_Makefile->GetDefinition("LIBRARY_OUTPUT_PATH");
}
std::string exePath = "";
if (m_Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH"))
{
exePath = m_Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH");
}
2001-06-05 23:48:09 +04:00
if(libPath.size())
{
// make sure there is a trailing slash
if(libPath[libPath.size()-1] != '/')
{
libPath += "/";
}
libOptions += " /LIBPATH:\"";
2001-08-28 22:55:14 +04:00
libOptions += cmSystemTools::HandleNetworkPaths(libPath.c_str());
2001-11-02 02:36:13 +03:00
libOptions += "$(INTDIR)\" ";
2001-06-05 23:48:09 +04:00
libOptions += " /LIBPATH:\"";
2001-08-28 22:55:14 +04:00
libOptions += cmSystemTools::HandleNetworkPaths(libPath.c_str());
2001-06-05 23:48:09 +04:00
libOptions += "\" ";
libMultiLineOptions += "# ADD LINK32 /LIBPATH:\"";
2001-08-28 22:55:14 +04:00
libMultiLineOptions += cmSystemTools::HandleNetworkPaths(libPath.c_str());
2001-11-02 02:36:13 +03:00
libMultiLineOptions += "$(INTDIR)\" ";
2001-06-05 23:48:09 +04:00
libMultiLineOptions += " /LIBPATH:\"";
2001-08-28 22:55:14 +04:00
libMultiLineOptions += cmSystemTools::HandleNetworkPaths(libPath.c_str());
2001-06-05 23:48:09 +04:00
libMultiLineOptions += "\" \n";
}
if(exePath.size())
{
// make sure there is a trailing slash
if(exePath[exePath.size()-1] != '/')
{
exePath += "/";
}
libOptions += " /LIBPATH:\"";
2001-08-28 22:55:14 +04:00
libOptions += cmSystemTools::HandleNetworkPaths(exePath.c_str());
2001-11-02 02:36:13 +03:00
libOptions += "$(INTDIR)\" ";
2001-06-05 23:48:09 +04:00
libOptions += " /LIBPATH:\"";
2001-08-28 22:55:14 +04:00
libOptions += cmSystemTools::HandleNetworkPaths(exePath.c_str());
2001-06-05 23:48:09 +04:00
libOptions += "\" ";
libMultiLineOptions += "# ADD LINK32 /LIBPATH:\"";
2001-08-28 22:55:14 +04:00
libMultiLineOptions += cmSystemTools::HandleNetworkPaths(exePath.c_str());
2001-11-02 02:36:13 +03:00
libMultiLineOptions += "$(INTDIR)\" ";
2001-06-05 23:48:09 +04:00
libMultiLineOptions += " /LIBPATH:\"";
2001-08-28 22:55:14 +04:00
libMultiLineOptions += cmSystemTools::HandleNetworkPaths(exePath.c_str());
2001-06-05 23:48:09 +04:00
libMultiLineOptions += "\" \n";
}
std::vector<std::string>::iterator i;
std::vector<std::string>& libdirs = m_Makefile->GetLinkDirectories();
2001-04-27 00:22:53 +04:00
for(i = libdirs.begin(); i != libdirs.end(); ++i)
{
libOptions += " /LIBPATH:\"";
2001-08-28 22:55:14 +04:00
libOptions += cmSystemTools::HandleNetworkPaths(i->c_str());
2001-11-02 02:36:13 +03:00
libOptions += "/$(INTDIR)\" ";
2001-04-27 00:22:53 +04:00
libOptions += " /LIBPATH:\"";
2001-08-28 22:55:14 +04:00
libOptions += cmSystemTools::HandleNetworkPaths(i->c_str());
2001-04-27 00:22:53 +04:00
libOptions += "\" ";
libMultiLineOptions += "# ADD LINK32 /LIBPATH:\"";
2001-08-28 22:55:14 +04:00
libMultiLineOptions += cmSystemTools::HandleNetworkPaths(i->c_str());
2001-11-02 02:36:13 +03:00
libMultiLineOptions += "/$(INTDIR)\" ";
libMultiLineOptions += " /LIBPATH:\"";
2001-08-28 22:55:14 +04:00
libMultiLineOptions += cmSystemTools::HandleNetworkPaths(i->c_str());
libMultiLineOptions += "\" \n";
2001-04-27 00:22:53 +04:00
}
// find link libraries
const cmTarget::LinkLibraries& libs = target.GetLinkLibraries();
cmTarget::LinkLibraries::const_iterator j;
2001-04-27 00:22:53 +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)
if ((target.GetType() != cmTarget::SHARED_LIBRARY
&& target.GetType() != cmTarget::STATIC_LIBRARY) ||
(target.GetType() == cmTarget::SHARED_LIBRARY && libName != j->first))
2001-04-27 00:22:53 +04:00
{
2001-05-10 00:17:03 +04:00
std::string lib = j->first;
if(j->first.find(".lib") == std::string::npos)
{
lib += ".lib";
}
lib = cmSystemTools::EscapeSpaces(lib.c_str());
if (j->second == cmTarget::GENERAL)
2001-04-27 00:22:53 +04:00
{
libOptions += " ";
libOptions += lib;
libMultiLineOptions += "# ADD LINK32 ";
libMultiLineOptions += lib;
libMultiLineOptions += "\n";
2001-04-27 00:22:53 +04:00
}
if (j->second == cmTarget::DEBUG)
2001-04-27 00:22:53 +04:00
{
libDebugOptions += " ";
2001-05-10 00:17:03 +04:00
libDebugOptions += lib;
libMultiLineDebugOptions += "# ADD LINK32 ";
libMultiLineDebugOptions += lib;
libMultiLineDebugOptions += "\n";
2001-04-27 00:22:53 +04:00
}
if (j->second == cmTarget::OPTIMIZED)
2001-04-27 00:22:53 +04:00
{
libOptimizedOptions += " ";
libOptimizedOptions += lib;
libMultiLineOptimizedOptions += "# ADD LINK32 ";
libMultiLineOptimizedOptions += lib;
libMultiLineOptimizedOptions += "\n";
2001-04-27 00:22:53 +04:00
}
}
}
std::string extraLinkOptions =
m_Makefile->GetDefinition("CMAKE_EXTRA_LINK_FLAGS");
if(extraLinkOptions.size())
{
2002-01-09 01:18:22 +03:00
libOptions += " ";
libOptions += extraLinkOptions;
2002-01-09 01:18:22 +03:00
libOptions += " ";
libMultiLineOptions += "# ADD LINK32 ";
libMultiLineOptions += extraLinkOptions;
libMultiLineOptions += " \n";
}
2001-04-27 00:22:53 +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);
std::ifstream fin(m_DSPHeaderTemplate.c_str());
if(!fin)
{
2001-02-23 03:24:43 +03:00
cmSystemTools::Error("Error Reading ", m_DSPHeaderTemplate.c_str());
}
char buffer[2048];
while(fin)
{
fin.getline(buffer, 2048);
std::string line = buffer;
const char* mfcFlag = m_Makefile->GetDefinition("CMAKE_MFC_FLAG");
if(!mfcFlag)
{
mfcFlag = "0";
}
cmSystemTools::ReplaceString(line, "CMAKE_CUSTOM_RULE_CODE",
customRuleCode.c_str());
cmSystemTools::ReplaceString(line, "CMAKE_MFC_FLAG",
mfcFlag);
cmSystemTools::ReplaceString(line, "CM_LIBRARIES",
2001-04-26 17:38:31 +04:00
libOptions.c_str());
2001-04-27 00:22:53 +04:00
cmSystemTools::ReplaceString(line, "CM_DEBUG_LIBRARIES",
libDebugOptions.c_str());
cmSystemTools::ReplaceString(line, "CM_OPTIMIZED_LIBRARIES",
libOptimizedOptions.c_str());
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());
cmSystemTools::ReplaceString(line, "BUILD_INCLUDES",
2001-04-26 17:38:31 +04:00
m_IncludeOptions.c_str());
cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME",libName);
cmSystemTools::ReplaceString(line, "LIBRARY_OUTPUT_PATH",
2001-08-28 22:55:14 +04:00
cmSystemTools::HandleNetworkPaths(libPath.c_str()).c_str());
cmSystemTools::ReplaceString(line, "EXECUTABLE_OUTPUT_PATH",
2001-08-28 22:55:14 +04:00
cmSystemTools::HandleNetworkPaths(exePath.c_str()).c_str());
cmSystemTools::ReplaceString(line,
2001-04-26 17:38:31 +04:00
"EXTRA_DEFINES",
m_Makefile->GetDefineFlags());
cmSystemTools::ReplaceString(line,
"CMAKE_CXX_FLAGS_RELEASE",
m_Makefile->
GetDefinition("CMAKE_CXX_FLAGS_RELEASE"));
cmSystemTools::ReplaceString(line,
"CMAKE_CXX_FLAGS_MINSIZEREL",
m_Makefile->
GetDefinition("CMAKE_CXX_FLAGS_MINSIZEREL")
);
cmSystemTools::ReplaceString(line,
"CMAKE_CXX_FLAGS_DEBUG",
m_Makefile->
GetDefinition("CMAKE_CXX_FLAGS_DEBUG"));
cmSystemTools::ReplaceString(line,
"CMAKE_CXX_FLAGS_RELWITHDEBINFO",
m_Makefile->
GetDefinition("CMAKE_CXX_FLAGS_RELWITHDEBINFO"));
cmSystemTools::ReplaceString(line,
"CMAKE_CXX_FLAGS",
m_Makefile->
GetDefinition("CMAKE_CXX_FLAGS"));
fout << line.c_str() << std::endl;
}
}
void cmDSPWriter::WriteDSPFooter(std::ostream& fout)
{
std::ifstream fin(m_DSPFooterTemplate.c_str());
if(!fin)
{
2001-02-23 03:24:43 +03:00
cmSystemTools::Error("Error Reading ",
m_DSPFooterTemplate.c_str());
}
char buffer[2048];
while(fin)
{
fin.getline(buffer, 2048);
fout << buffer << std::endl;
}
}