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
|
|
|
|
|
|
|
=========================================================================*/
|
2001-06-06 21:48:13 +04:00
|
|
|
#include "cmDSPWriter.h"
|
2001-01-05 19:41:20 +03:00
|
|
|
#include "cmStandardIncludes.h"
|
2000-08-29 23:26:29 +04:00
|
|
|
#include "cmSystemTools.h"
|
2001-02-27 01:17:34 +03:00
|
|
|
#include "cmRegularExpression.h"
|
2001-02-23 03:24:43 +03:00
|
|
|
|
2001-06-06 21:48:13 +04:00
|
|
|
cmDSPWriter::~cmDSPWriter()
|
2001-01-05 19:41:20 +03:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2000-08-30 21:35:41 +04:00
|
|
|
|
2001-06-06 21:48:13 +04:00
|
|
|
cmDSPWriter::cmDSPWriter(cmMakefile*mf)
|
2001-01-05 19:41:20 +03:00
|
|
|
{
|
|
|
|
m_Makefile = mf;
|
|
|
|
}
|
2000-08-30 21:35:41 +04:00
|
|
|
|
2001-06-06 21:48:13 +04:00
|
|
|
void cmDSPWriter::OutputDSPFile()
|
2000-08-29 23:26:29 +04:00
|
|
|
{
|
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
|
2001-07-30 19:34:03 +04:00
|
|
|
std::vector<std::string>& includes = m_Makefile->GetIncludeDirectories();
|
|
|
|
std::vector<std::string>::iterator i;
|
2000-09-12 13:30:35 +04:00
|
|
|
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;
|
|
|
|
}
|
2000-09-12 13:30:35 +04:00
|
|
|
}
|
2001-02-23 03:24:43 +03:00
|
|
|
|
|
|
|
// Create the DSP or set of DSP's for libraries and executables
|
2001-04-11 22:59:02 +04:00
|
|
|
|
|
|
|
// 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();
|
2001-04-11 22:59:02 +04:00
|
|
|
l != tgts.end(); l++)
|
|
|
|
{
|
2001-05-02 00:55:32 +04:00
|
|
|
switch(l->second.GetType())
|
2001-02-28 00:50:51 +03:00
|
|
|
{
|
2001-07-02 23:38:02 +04:00
|
|
|
case cmTarget::STATIC_LIBRARY:
|
|
|
|
this->SetBuildType(STATIC_LIBRARY, l->first.c_str());
|
|
|
|
break;
|
|
|
|
case cmTarget::SHARED_LIBRARY:
|
|
|
|
this->SetBuildType(DLL, l->first.c_str());
|
2001-05-02 00:55:32 +04:00
|
|
|
break;
|
|
|
|
case cmTarget::EXECUTABLE:
|
|
|
|
this->SetBuildType(EXECUTABLE,l->first.c_str());
|
|
|
|
break;
|
2001-05-11 18:53:17 +04:00
|
|
|
case cmTarget::WIN32_EXECUTABLE:
|
|
|
|
this->SetBuildType(WIN32_EXECUTABLE,l->first.c_str());
|
|
|
|
break;
|
2001-05-02 00:55:32 +04:00
|
|
|
case cmTarget::UTILITY:
|
|
|
|
this->SetBuildType(UTILITY, l->first.c_str());
|
|
|
|
break;
|
2001-07-31 19:29:21 +04:00
|
|
|
case cmTarget::INSTALL_FILES:
|
|
|
|
break;
|
|
|
|
case cmTarget::INSTALL_PROGRAMS:
|
2001-05-23 21:16:09 +04:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
cmSystemTools::Error("Bad target type", l->first.c_str());
|
|
|
|
break;
|
2000-08-29 23:26:29 +04:00
|
|
|
}
|
2001-10-31 15:03:32 +03:00
|
|
|
// INCLUDE_EXTERNAL_MSPROJECT command only affects the workspace
|
|
|
|
// so don't build a projectfile for it
|
2001-07-31 19:29:21 +04:00
|
|
|
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);
|
|
|
|
}
|
2000-08-29 23:26:29 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-06-06 21:48:13 +04:00
|
|
|
void cmDSPWriter::CreateSingleDSP(const char *lname, cmTarget &target)
|
2000-08-29 23:26:29 +04:00
|
|
|
{
|
|
|
|
std::string fname;
|
2001-02-15 21:30:13 +03:00
|
|
|
fname = m_Makefile->GetStartOutputDirectory();
|
2000-08-29 23:26:29 +04:00
|
|
|
fname += "/";
|
2001-04-11 22:59:02 +04:00
|
|
|
fname += lname;
|
2000-08-29 23:26:29 +04:00
|
|
|
fname += ".dsp";
|
2001-04-11 22:59:02 +04:00
|
|
|
std::string pname = lname;
|
2000-08-29 23:26:29 +04:00
|
|
|
m_CreatedProjectNames.push_back(pname);
|
|
|
|
std::ofstream fout(fname.c_str());
|
|
|
|
if(!fout)
|
|
|
|
{
|
2001-04-11 22:59:02 +04:00
|
|
|
cmSystemTools::Error("Error Writing ", fname.c_str());
|
2000-08-30 21:35:41 +04:00
|
|
|
}
|
2001-04-27 00:22:53 +04:00
|
|
|
this->WriteDSPFile(fout,lname,target);
|
2000-08-29 23:26:29 +04:00
|
|
|
}
|
|
|
|
|
2001-05-02 00:55:32 +04:00
|
|
|
|
2001-06-06 21:48:13 +04:00
|
|
|
void cmDSPWriter::AddDSPBuildRule(cmSourceGroup& sourceGroup)
|
2001-03-20 21:20:59 +03:00
|
|
|
{
|
|
|
|
std::string dspname = *(m_CreatedProjectNames.end()-1);
|
2001-08-23 00:33:58 +04:00
|
|
|
if(dspname == "ALL_BUILD")
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2001-03-20 21:20:59 +03:00
|
|
|
dspname += ".dsp";
|
2001-08-28 22:55:14 +04:00
|
|
|
std::string makefileIn = m_Makefile->GetStartDirectory();
|
2001-03-20 21:20:59 +03:00
|
|
|
makefileIn += "/";
|
2001-08-28 22:55:14 +04:00
|
|
|
makefileIn += "CMakeLists.txt";
|
|
|
|
makefileIn = cmSystemTools::HandleNetworkPaths(makefileIn.c_str());
|
2001-11-21 01:26:45 +03:00
|
|
|
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());
|
2001-09-05 00:07:54 +04:00
|
|
|
std::string args = makefileIn;
|
2001-11-22 01:45:01 +03:00
|
|
|
args += " -H\"";
|
2001-09-05 00:07:54 +04:00
|
|
|
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
|
|
|
|
2001-03-20 21:20:59 +03:00
|
|
|
std::vector<std::string> outputs;
|
|
|
|
outputs.push_back(dspname);
|
2001-04-11 22:59:02 +04:00
|
|
|
cmCustomCommand cc(makefileIn.c_str(), dsprule.c_str(),
|
2001-09-05 00:07:54 +04:00
|
|
|
args.c_str(),
|
2001-04-30 18:52:58 +04:00
|
|
|
m_Makefile->GetListFiles(),
|
|
|
|
outputs);
|
2001-04-11 22:59:02 +04:00
|
|
|
sourceGroup.AddCustomCommand(cc);
|
2000-08-29 23:26:29 +04:00
|
|
|
}
|
|
|
|
|
2001-03-20 21:20:59 +03:00
|
|
|
|
2001-06-06 21:48:13 +04:00
|
|
|
void cmDSPWriter::WriteDSPFile(std::ostream& fout,
|
2001-04-11 22:59:02 +04:00
|
|
|
const char *libName,
|
2001-04-27 00:22:53 +04:00
|
|
|
cmTarget &target)
|
2000-08-29 23:26:29 +04:00
|
|
|
{
|
2001-03-20 21:20:59 +03:00
|
|
|
// We may be modifying the source groups temporarily, so make a copy.
|
|
|
|
std::vector<cmSourceGroup> sourceGroups = m_Makefile->GetSourceGroups();
|
|
|
|
|
2001-04-11 22:59:02 +04:00
|
|
|
// 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();
|
2001-04-11 22:59:02 +04:00
|
|
|
i != classes.end(); i++)
|
|
|
|
{
|
2001-04-25 00:49:12 +04:00
|
|
|
if(!i->IsAHeaderFileOnly())
|
2001-04-11 22:59:02 +04:00
|
|
|
{
|
|
|
|
// Add the file to the list of sources.
|
2001-04-25 00:49:12 +04:00
|
|
|
std::string source = i->GetFullPath();
|
2001-04-11 22:59:02 +04:00
|
|
|
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 =
|
2001-04-19 21:28:46 +04:00
|
|
|
target.GetCustomCommands().begin();
|
|
|
|
cr != target.GetCustomCommands().end(); ++cr)
|
2001-04-11 22:59:02 +04:00
|
|
|
{
|
|
|
|
cmSourceGroup& sourceGroup =
|
2001-04-19 21:28:46 +04:00
|
|
|
m_Makefile->FindSourceGroup(cr->GetSourceName().c_str(),
|
2001-04-11 22:59:02 +04:00
|
|
|
sourceGroups);
|
|
|
|
cmCustomCommand cc(*cr);
|
|
|
|
cc.ExpandVariables(*m_Makefile);
|
|
|
|
sourceGroup.AddCustomCommand(cc);
|
|
|
|
}
|
|
|
|
|
2001-11-09 21:00:53 +03:00
|
|
|
// Write the DSP file's header.
|
|
|
|
this->WriteDSPHeader(fout, libName, target, sourceGroups);
|
|
|
|
|
2001-03-20 21:20:59 +03:00
|
|
|
// 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)
|
|
|
|
{
|
2001-04-27 22:51:43 +04:00
|
|
|
const cmSourceGroup::BuildRules& buildRules = sg->GetBuildRules();
|
2001-03-20 21:20:59 +03:00
|
|
|
// If the group is empty, don't write it at all.
|
2001-04-27 22:51:43 +04:00
|
|
|
if(buildRules.empty())
|
2001-03-20 21:20:59 +03:00
|
|
|
{ continue; }
|
|
|
|
|
|
|
|
// If the group has a name, write the header.
|
|
|
|
std::string name = sg->GetName();
|
|
|
|
if(name != "")
|
|
|
|
{
|
|
|
|
this->WriteDSPBeginGroup(fout, name.c_str(), "");
|
|
|
|
}
|
|
|
|
|
2001-04-27 22:51:43 +04:00
|
|
|
// Loop through each build rule in the source group.
|
|
|
|
for(cmSourceGroup::BuildRules::const_iterator cc =
|
|
|
|
buildRules.begin(); cc != buildRules.end(); ++ cc)
|
2001-03-20 21:20:59 +03:00
|
|
|
{
|
|
|
|
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)
|
2001-03-20 21:20:59 +03:00
|
|
|
{
|
2001-11-09 21:00:53 +03: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=" << cmSystemTools::EscapeSpaces(source.c_str()) << "\n\n";
|
|
|
|
if (!commands.empty())
|
2001-05-04 17:39:05 +04:00
|
|
|
{
|
2001-11-09 21:00:53 +03: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
|
|
|
}
|
2001-11-09 21:00:53 +03:00
|
|
|
fout << "# End Source File\n";
|
2001-05-04 17:39:05 +04:00
|
|
|
}
|
2001-03-20 21:20:59 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// If the group has a name, write the footer.
|
|
|
|
if(name != "")
|
|
|
|
{
|
|
|
|
this->WriteDSPEndGroup(fout);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Write the DSP file's footer.
|
2000-08-29 23:26:29 +04:00
|
|
|
this->WriteDSPFooter(fout);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-06-06 21:48:13 +04:00
|
|
|
void cmDSPWriter::WriteCustomRule(std::ostream& fout,
|
2001-05-02 00:55:32 +04:00
|
|
|
const char* source,
|
2001-02-27 01:17:34 +03:00
|
|
|
const char* command,
|
2001-03-20 21:20:59 +03:00
|
|
|
const std::set<std::string>& depends,
|
|
|
|
const std::set<std::string>& outputs)
|
2000-08-29 23:26:29 +04:00
|
|
|
{
|
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;
|
|
|
|
}
|
2001-05-02 00:55:32 +04:00
|
|
|
|
2001-07-25 00:16:02 +04:00
|
|
|
// Write out the dependencies for the rule.
|
|
|
|
fout << "USERDEP__HACK=";
|
2001-09-02 00:56:41 +04:00
|
|
|
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)
|
|
|
|
{
|
2001-09-02 00:56:41 +04:00
|
|
|
temp = *d;
|
|
|
|
fout << "\\\n\t" << cmSystemTools::EscapeSpaces(cmSystemTools::ConvertToWindowsSlashes(temp));
|
2001-04-30 18:52:58 +04:00
|
|
|
}
|
|
|
|
fout << "\n";
|
|
|
|
|
2001-12-17 19:15:23 +03:00
|
|
|
fout << "# PROP Ignore_Default_Tool 1\n";
|
2001-02-27 01:17:34 +03:00
|
|
|
fout << "# Begin Custom Build\n\n";
|
2001-05-02 00:55:32 +04:00
|
|
|
if(outputs.size() == 0)
|
|
|
|
{
|
|
|
|
fout << source << "_force : \"$(SOURCE)\" \"$(INTDIR)\" \"$(OUTDIR)\"";
|
2001-05-04 17:39:05 +04:00
|
|
|
fout << command << "\n\n";
|
2001-05-02 00:55:32 +04:00
|
|
|
}
|
2001-03-20 21:20:59 +03:00
|
|
|
|
|
|
|
// 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
|
|
|
{
|
2001-03-20 21:20:59 +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-03-20 21:20:59 +03:00
|
|
|
|
2001-02-27 01:17:34 +03:00
|
|
|
fout << "# End Custom Build\n\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
fout << "!ENDIF\n\n";
|
2000-08-29 23:26:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-06-06 21:48:13 +04:00
|
|
|
void cmDSPWriter::WriteDSPBeginGroup(std::ostream& fout,
|
2000-08-29 23:26:29 +04:00
|
|
|
const char* group,
|
|
|
|
const char* filter)
|
|
|
|
{
|
|
|
|
fout << "# Begin Group \"" << group << "\"\n"
|
|
|
|
"# PROP Default_Filter \"" << filter << "\"\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-06-06 21:48:13 +04:00
|
|
|
void cmDSPWriter::WriteDSPEndGroup(std::ostream& fout)
|
2000-08-29 23:26:29 +04:00
|
|
|
{
|
|
|
|
fout << "# End Group\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2001-06-06 21:48:13 +04:00
|
|
|
void cmDSPWriter::SetBuildType(BuildType b, const char *libName)
|
2000-08-29 23:26:29 +04:00
|
|
|
{
|
2001-08-08 19:54:46 +04:00
|
|
|
std::string root= m_Makefile->GetDefinition("CMAKE_ROOT");
|
2001-05-10 22:30:16 +04:00
|
|
|
const char *def= m_Makefile->GetDefinition( "MSPROJECT_TEMPLATE_DIRECTORY");
|
|
|
|
|
|
|
|
if( def)
|
|
|
|
{
|
2001-05-17 20:08:46 +04:00
|
|
|
root = def;
|
2001-05-10 22:30:16 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2001-05-17 20:08:46 +04:00
|
|
|
root += "/Templates";
|
2001-05-10 22:30:16 +04:00
|
|
|
}
|
2001-05-17 20:08:46 +04:00
|
|
|
|
2000-08-29 23:26:29 +04:00
|
|
|
switch(b)
|
|
|
|
{
|
|
|
|
case STATIC_LIBRARY:
|
2001-05-10 22:30:16 +04:00
|
|
|
m_DSPHeaderTemplate = root;
|
|
|
|
m_DSPHeaderTemplate += "/staticLibHeader.dsptemplate";
|
|
|
|
m_DSPFooterTemplate = root;
|
|
|
|
m_DSPFooterTemplate += "/staticLibFooter.dsptemplate";
|
2000-08-29 23:26:29 +04:00
|
|
|
break;
|
|
|
|
case DLL:
|
2001-05-10 22:30:16 +04:00
|
|
|
m_DSPHeaderTemplate = root;
|
|
|
|
m_DSPHeaderTemplate += "/DLLHeader.dsptemplate";
|
|
|
|
m_DSPFooterTemplate = root;
|
|
|
|
m_DSPFooterTemplate += "/DLLFooter.dsptemplate";
|
2000-08-29 23:26:29 +04:00
|
|
|
break;
|
|
|
|
case EXECUTABLE:
|
2001-05-10 22:30:16 +04:00
|
|
|
m_DSPHeaderTemplate = root;
|
|
|
|
m_DSPHeaderTemplate += "/EXEHeader.dsptemplate";
|
|
|
|
m_DSPFooterTemplate = root;
|
|
|
|
m_DSPFooterTemplate += "/EXEFooter.dsptemplate";
|
2000-08-29 23:26:29 +04:00
|
|
|
break;
|
2001-05-11 18:53:17 +04:00
|
|
|
case WIN32_EXECUTABLE:
|
2001-05-23 04:36:54 +04:00
|
|
|
m_DSPHeaderTemplate = root;
|
|
|
|
m_DSPHeaderTemplate += "/EXEWinHeader.dsptemplate";
|
|
|
|
m_DSPFooterTemplate = root;
|
|
|
|
m_DSPFooterTemplate += "/EXEFooter.dsptemplate";
|
2001-05-11 18:53:17 +04:00
|
|
|
break;
|
2001-05-02 00:55:32 +04:00
|
|
|
case UTILITY:
|
2001-05-10 22:30:16 +04:00
|
|
|
m_DSPHeaderTemplate = root;
|
|
|
|
m_DSPHeaderTemplate += "/UtilityHeader.dsptemplate";
|
|
|
|
m_DSPFooterTemplate = root;
|
|
|
|
m_DSPFooterTemplate += "/UtilityFooter.dsptemplate";
|
2001-05-02 00:55:32 +04:00
|
|
|
break;
|
2000-08-29 23:26:29 +04:00
|
|
|
}
|
|
|
|
|
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-05-10 22:30:16 +04:00
|
|
|
|
2001-02-27 01:17:34 +03:00
|
|
|
cmRegularExpression reg("# Name ");
|
|
|
|
if(!fin)
|
|
|
|
{
|
|
|
|
cmSystemTools::Error("Error Reading ", m_DSPHeaderTemplate.c_str());
|
|
|
|
}
|
2001-04-06 16:28:57 +04:00
|
|
|
|
|
|
|
// 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;
|
2001-04-11 22:59:02 +04:00
|
|
|
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()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2001-11-09 21:00:53 +03:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2000-08-29 23:26:29 +04:00
|
|
|
|
2001-11-09 21:00:53 +03:00
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
|
2001-06-06 21:48:13 +04:00
|
|
|
void cmDSPWriter::WriteDSPHeader(std::ostream& fout, const char *libName,
|
2001-11-09 21:00:53 +03:00
|
|
|
const cmTarget &target,
|
2001-12-01 01:20:43 +03:00
|
|
|
std::vector<cmSourceGroup> &)
|
2000-08-29 23:26:29 +04:00
|
|
|
{
|
2001-04-27 00:22:53 +04:00
|
|
|
// determine the link directories
|
|
|
|
std::string libOptions;
|
|
|
|
std::string libDebugOptions;
|
|
|
|
std::string libOptimizedOptions;
|
2001-05-10 02:00:03 +04:00
|
|
|
|
|
|
|
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";
|
|
|
|
}
|
2001-07-30 19:34:03 +04:00
|
|
|
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 += "\" ";
|
2001-05-10 02:00:03 +04:00
|
|
|
|
|
|
|
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)\" ";
|
2001-05-10 02:00:03 +04:00
|
|
|
libMultiLineOptions += " /LIBPATH:\"";
|
2001-08-28 22:55:14 +04:00
|
|
|
libMultiLineOptions += cmSystemTools::HandleNetworkPaths(i->c_str());
|
2001-05-10 02:00:03 +04:00
|
|
|
libMultiLineOptions += "\" \n";
|
2001-04-27 00:22:53 +04:00
|
|
|
}
|
|
|
|
// find link libraries
|
2001-04-30 18:44:00 +04:00
|
|
|
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)
|
2001-07-02 23:38:02 +04:00
|
|
|
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());
|
2001-08-27 23:19:45 +04:00
|
|
|
|
2001-04-30 18:44:00 +04:00
|
|
|
if (j->second == cmTarget::GENERAL)
|
2001-04-27 00:22:53 +04:00
|
|
|
{
|
|
|
|
libOptions += " ";
|
2001-08-27 23:19:45 +04:00
|
|
|
libOptions += lib;
|
|
|
|
|
2001-05-10 02:00:03 +04:00
|
|
|
libMultiLineOptions += "# ADD LINK32 ";
|
|
|
|
libMultiLineOptions += lib;
|
|
|
|
libMultiLineOptions += "\n";
|
2001-04-27 00:22:53 +04:00
|
|
|
}
|
2001-04-30 18:44:00 +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;
|
2001-05-10 02:00:03 +04:00
|
|
|
|
|
|
|
libMultiLineDebugOptions += "# ADD LINK32 ";
|
|
|
|
libMultiLineDebugOptions += lib;
|
|
|
|
libMultiLineDebugOptions += "\n";
|
2001-04-27 00:22:53 +04:00
|
|
|
}
|
2001-04-30 18:44:00 +04:00
|
|
|
if (j->second == cmTarget::OPTIMIZED)
|
2001-04-27 00:22:53 +04:00
|
|
|
{
|
|
|
|
libOptimizedOptions += " ";
|
2001-08-27 23:19:45 +04:00
|
|
|
libOptimizedOptions += lib;
|
2001-05-10 02:00:03 +04:00
|
|
|
|
|
|
|
libMultiLineOptimizedOptions += "# ADD LINK32 ";
|
|
|
|
libMultiLineOptimizedOptions += lib;
|
|
|
|
libMultiLineOptimizedOptions += "\n";
|
2001-04-27 00:22:53 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2002-01-08 21:33:00 +03:00
|
|
|
std::string extraLinkOptions =
|
|
|
|
m_Makefile->GetDefinition("CMAKE_EXTRA_LINK_FLAGS");
|
|
|
|
if(extraLinkOptions.size())
|
|
|
|
{
|
|
|
|
libOptions += extraLinkOptions;
|
|
|
|
libMultiLineOptions += "# ADD LINK32 ";
|
|
|
|
libMultiLineOptions += extraLinkOptions;
|
|
|
|
libMultiLineOptions += " \n";
|
|
|
|
}
|
2001-04-27 00:22:53 +04:00
|
|
|
|
2001-11-09 21:00:53 +03: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);
|
|
|
|
|
2000-08-29 23:26:29 +04:00
|
|
|
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());
|
2000-08-29 23:26:29 +04:00
|
|
|
}
|
|
|
|
char buffer[2048];
|
2001-01-12 22:05:11 +03:00
|
|
|
|
2000-08-29 23:26:29 +04:00
|
|
|
while(fin)
|
|
|
|
{
|
|
|
|
fin.getline(buffer, 2048);
|
|
|
|
std::string line = buffer;
|
2001-06-21 00:49:09 +04:00
|
|
|
const char* mfcFlag = m_Makefile->GetDefinition("CMAKE_MFC_FLAG");
|
|
|
|
if(!mfcFlag)
|
|
|
|
{
|
|
|
|
mfcFlag = "0";
|
|
|
|
}
|
2001-11-09 21:00:53 +03:00
|
|
|
cmSystemTools::ReplaceString(line, "CMAKE_CUSTOM_RULE_CODE",
|
|
|
|
customRuleCode.c_str());
|
2001-06-21 00:49:09 +04:00
|
|
|
cmSystemTools::ReplaceString(line, "CMAKE_MFC_FLAG",
|
|
|
|
mfcFlag);
|
2001-03-10 00:56:38 +03:00
|
|
|
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());
|
2001-05-10 02:00:03 +04: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());
|
|
|
|
|
2000-08-29 23:26:29 +04:00
|
|
|
cmSystemTools::ReplaceString(line, "BUILD_INCLUDES",
|
2001-04-26 17:38:31 +04:00
|
|
|
m_IncludeOptions.c_str());
|
2001-04-11 22:59:02 +04:00
|
|
|
cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME",libName);
|
2001-05-22 20:39:22 +04:00
|
|
|
cmSystemTools::ReplaceString(line, "LIBRARY_OUTPUT_PATH",
|
2001-08-28 22:55:14 +04:00
|
|
|
cmSystemTools::HandleNetworkPaths(libPath.c_str()).c_str());
|
2001-05-22 20:39:22 +04:00
|
|
|
cmSystemTools::ReplaceString(line, "EXECUTABLE_OUTPUT_PATH",
|
2001-08-28 22:55:14 +04:00
|
|
|
cmSystemTools::HandleNetworkPaths(exePath.c_str()).c_str());
|
2000-08-29 23:26:29 +04:00
|
|
|
cmSystemTools::ReplaceString(line,
|
2001-04-26 17:38:31 +04:00
|
|
|
"EXTRA_DEFINES",
|
2001-01-12 22:05:11 +03:00
|
|
|
m_Makefile->GetDefineFlags());
|
2001-05-24 01:19:38 +04:00
|
|
|
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"));
|
2001-06-07 19:36:55 +04:00
|
|
|
cmSystemTools::ReplaceString(line,
|
2001-07-03 13:27:39 +04:00
|
|
|
"CMAKE_CXX_FLAGS_RELWITHDEBINFO",
|
2001-06-07 19:36:55 +04:00
|
|
|
m_Makefile->
|
2001-07-03 13:27:39 +04:00
|
|
|
GetDefinition("CMAKE_CXX_FLAGS_RELWITHDEBINFO"));
|
2001-05-24 01:19:38 +04:00
|
|
|
cmSystemTools::ReplaceString(line,
|
|
|
|
"CMAKE_CXX_FLAGS",
|
|
|
|
m_Makefile->
|
|
|
|
GetDefinition("CMAKE_CXX_FLAGS"));
|
|
|
|
|
2000-08-29 23:26:29 +04:00
|
|
|
fout << line.c_str() << std::endl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-06-06 21:48:13 +04:00
|
|
|
void cmDSPWriter::WriteDSPFooter(std::ostream& fout)
|
2000-08-29 23:26:29 +04:00
|
|
|
{
|
|
|
|
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());
|
2000-08-29 23:26:29 +04:00
|
|
|
}
|
|
|
|
char buffer[2048];
|
|
|
|
while(fin)
|
|
|
|
{
|
|
|
|
fin.getline(buffer, 2048);
|
|
|
|
fout << buffer << std::endl;
|
|
|
|
}
|
|
|
|
}
|