From 60b9a2c14bf1883ba18c4cf650675382554c2627 Mon Sep 17 00:00:00 2001 From: Bill Hoffman Date: Mon, 18 Feb 2002 14:36:04 -0500 Subject: ENH: first pass at dot net support --- Source/CMakeLib.dsp | 12 + Source/cmMSDotNETGenerator.cxx | 71 ++++++ Source/cmMSDotNETGenerator.h | 85 +++++++ Source/cmSLNWriter.cxx | 404 +++++++++++++++++++++++++++++++++ Source/cmSLNWriter.h | 62 ++++++ Source/cmSystemTools.cxx | 55 ++++- Source/cmVCProjWriter.cxx | 496 +++++++++++++++++++++++++++++++++++++++++ Source/cmVCProjWriter.h | 99 ++++++++ Source/cmake.cxx | 2 + Source/cmake.dsp | 2 +- 10 files changed, 1281 insertions(+), 7 deletions(-) create mode 100644 Source/cmMSDotNETGenerator.cxx create mode 100644 Source/cmMSDotNETGenerator.h create mode 100644 Source/cmSLNWriter.cxx create mode 100644 Source/cmSLNWriter.h create mode 100644 Source/cmVCProjWriter.cxx create mode 100644 Source/cmVCProjWriter.h diff --git a/Source/CMakeLib.dsp b/Source/CMakeLib.dsp index 58ea7c0..070d8ef 100644 --- a/Source/CMakeLib.dsp +++ b/Source/CMakeLib.dsp @@ -151,6 +151,18 @@ SOURCE=.\cmMSProjectGenerator.cxx # End Source File # Begin Source File +SOURCE=.\cmMSDotNETGenerator.cxx +# End Source File +# Begin Source File + +SOURCE=.\cmSLNWriter.cxx +# End Source File +# Begin Source File + +SOURCE=.\cmVCProjWriter.cxx +# End Source File +# Begin Source File + SOURCE=.\cmRegularExpression.cxx # End Source File # Begin Source File diff --git a/Source/cmMSDotNETGenerator.cxx b/Source/cmMSDotNETGenerator.cxx new file mode 100644 index 0000000..d1c17fe --- /dev/null +++ b/Source/cmMSDotNETGenerator.cxx @@ -0,0 +1,71 @@ +/*========================================================================= + + Program: Insight Segmentation & Registration Toolkit + Module: $RCSfile$ + Language: C++ + Date: $Date$ + Version: $Revision$ + + Copyright (c) 2002 Insight Consortium. All rights reserved. + See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notices for more information. + +=========================================================================*/ +#include "cmMSDotNETGenerator.h" +#include "cmSLNWriter.h" +#include "cmVCProjWriter.h" +#include "cmCacheManager.h" + +cmMSDotNETGenerator::cmMSDotNETGenerator() +{ + m_SLNWriter = 0; + m_VCProjWriter = 0; + BuildProjOn(); +} + +void cmMSDotNETGenerator::GenerateMakefile() +{ + if(m_BuildSLN) + { + delete m_SLNWriter; + m_SLNWriter = 0; + m_SLNWriter = new cmSLNWriter(m_Makefile); + m_SLNWriter->OutputSLNFile(); + } + else + { + delete m_VCProjWriter; + m_VCProjWriter = 0; + m_VCProjWriter = new cmVCProjWriter(m_Makefile); + m_VCProjWriter->OutputVCProjFile(); + } +} + +cmMSDotNETGenerator::~cmMSDotNETGenerator() +{ + delete m_VCProjWriter; + delete m_SLNWriter; +} + +void cmMSDotNETGenerator::SetLocal(bool local) +{ + m_BuildSLN = !local; +} + +void cmMSDotNETGenerator::ComputeSystemInfo() +{ + // now load the settings + if(!m_Makefile->GetDefinition("CMAKE_ROOT")) + { + cmSystemTools::Error( + "CMAKE_ROOT has not been defined, bad GUI or driver program"); + return; + } + std::string fpath = + m_Makefile->GetDefinition("CMAKE_ROOT"); + fpath += "/Templates/CMakeWindowsSystemConfig.cmake"; + m_Makefile->ReadListFile(NULL,fpath.c_str()); +} diff --git a/Source/cmMSDotNETGenerator.h b/Source/cmMSDotNETGenerator.h new file mode 100644 index 0000000..5a0fb2f --- /dev/null +++ b/Source/cmMSDotNETGenerator.h @@ -0,0 +1,85 @@ +/*========================================================================= + + Program: Insight Segmentation & Registration Toolkit + Module: $RCSfile$ + Language: C++ + Date: $Date$ + Version: $Revision$ + + Copyright (c) 2002 Insight Consortium. All rights reserved. + See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notices for more information. + +=========================================================================*/ +#ifndef cmMSDotNETGenerator_h +#define cmMSDotNETGenerator_h + +#include "cmStandardIncludes.h" +#include "cmMakefileGenerator.h" + +class cmVCProjWriter; +class cmSLNWriter; + +/** \class cmMSDotNETGenerator + * \brief Write a Microsoft Visual C++ DSP (project) file. + * + * cmMSDotNETGenerator produces a Microsoft Visual C++ DSP (project) file. + */ +class cmMSDotNETGenerator : public cmMakefileGenerator +{ +public: + ///! Constructor sets the generation of SLN files on. + cmMSDotNETGenerator(); + + ///! Destructor. + ~cmMSDotNETGenerator(); + + ///! Get the name for the generator. + virtual const char* GetName() {return "Visual Studio 7";} + + ///! virtual copy constructor + virtual cmMakefileGenerator* CreateObject() + { return new cmMSDotNETGenerator;} + + ///! Produce the makefile (in this case a Microsoft Visual C++ project). + virtual void GenerateMakefile(); + + ///! controls the SLN/DSP settings + virtual void SetLocal(bool); + + /** + * Turn off the generation of a Microsoft Visual C++ SLN file. + * This causes only the dsp file to be created. This + * is used to run as a command line program from inside visual + * studio. + */ + void BuildSLNOff() {m_BuildSLN = false;} + + ///! Turn on the generation of a Microsoft Visual C++ SLN file. + void BuildProjOn() {m_BuildSLN = true;} + + ///! Retrieve a pointer to a cmSLNWriter instance. + cmSLNWriter* GetSLNWriter() + {return m_SLNWriter;} + + ///! Retrieve a pointer to a cmVCProjWriter instance. + cmVCProjWriter* GetVCProjWriter() + {return m_VCProjWriter;} + + /** + * Try to determine system infomation such as shared library + * extension, pthreads, byte order etc. + */ + virtual void ComputeSystemInfo(); + +private: + cmSLNWriter* m_SLNWriter; + cmVCProjWriter* m_VCProjWriter; + bool m_BuildSLN; +}; + + +#endif diff --git a/Source/cmSLNWriter.cxx b/Source/cmSLNWriter.cxx new file mode 100644 index 0000000..a1d27ac --- /dev/null +++ b/Source/cmSLNWriter.cxx @@ -0,0 +1,404 @@ +/*========================================================================= + + Program: Insight Segmentation & Registration Toolkit + Module: $RCSfile$ + Language: C++ + Date: $Date$ + Version: $Revision$ + + Copyright (c) 2002 Insight Consortium. All rights reserved. + See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notices for more information. + +=========================================================================*/ +#include "cmSLNWriter.h" +#include "cmStandardIncludes.h" +#include "cmSystemTools.h" +#include "cmVCProjWriter.h" +#include "cmMSDotNETGenerator.h" +#include "cmCacheManager.h" +#include "windows.h" + +cmSLNWriter::cmSLNWriter(cmMakefile* m) +{ + m_Makefile = m; +} + +// output the SLN file +void cmSLNWriter::OutputSLNFile() +{ + // if this is an out of source build, create the output directory + if(strcmp(m_Makefile->GetStartOutputDirectory(), + m_Makefile->GetHomeDirectory()) != 0) + { + if(!cmSystemTools::MakeDirectory(m_Makefile->GetStartOutputDirectory())) + { + cmSystemTools::Error("Error creating output directory for SLN file", + m_Makefile->GetStartOutputDirectory()); + } + } + // create the dsw file name + std::string fname; + fname = m_Makefile->GetStartOutputDirectory(); + fname += "/"; + if(strlen(m_Makefile->GetProjectName()) == 0) + { + m_Makefile->SetProjectName("Project"); + } + fname += m_Makefile->GetProjectName(); + fname += ".sln"; + std::ofstream fout(fname.c_str()); + if(!fout) + { + cmSystemTools::Error("Error can not open SLN file for write: " + ,fname.c_str()); + return; + } + this->WriteSLNFile(fout); +} + + +// Write a SLN file to the stream +void cmSLNWriter::WriteSLNFile(std::ostream& fout) +{ + // Write out the header for a SLN file + this->WriteSLNHeader(fout); + + // Create a list of cmMakefile created from all the + // CMakeLists.txt files that are in sub directories of + // this one. + std::vector allListFiles; + // add this makefile to the list + allListFiles.push_back(m_Makefile); + // add a special target that depends on ALL projects for easy build + // of Debug only + m_Makefile->AddUtilityCommand("ALL_BUILD", "echo", "\"Build all projects\"", + false); + m_Makefile->FindSubDirectoryCMakeListsFiles(allListFiles); + // For each cmMakefile, create a VCProj for it, and + // add it to this SLN file + std::vector::iterator k; + for(k = allListFiles.begin(); + k != allListFiles.end(); ++k) + { + cmMakefile* mf = *k; + cmMSDotNETGenerator* pg = 0; + // if not this makefile, then create a new generator + if(m_Makefile != mf) + { + // Create an MS generator with SLN off, so it only creates dsp files + pg = new cmMSDotNETGenerator; + } + else + { + pg = static_cast(m_Makefile->GetMakefileGenerator()); + } + // make sure the generator is building dsp files + pg->BuildSLNOff(); + mf->SetMakefileGenerator(pg); + mf->GenerateMakefile(); + // Get the source directory from the makefile + std::string dir = mf->GetStartDirectory(); + // Get the home directory with the trailing slash + std::string homedir = m_Makefile->GetHomeDirectory(); + homedir += "/"; + // remove the home directory and / from the source directory + // this gives a relative path + cmSystemTools::ReplaceString(dir, homedir.c_str(), ""); + + // Get the list of create dsp files names from the cmVCProjWriter, more + // than one dsp could have been created per input CMakeLists.txt file + // for each target + std::vector dspnames = + pg->GetVCProjWriter()->GetCreatedProjectNames(); + cmTargets &tgts = pg->GetVCProjWriter()->GetMakefile()->GetTargets(); + cmTargets::iterator l = tgts.begin(); + for(std::vector::iterator si = dspnames.begin(); + l != tgts.end(); ++l) + { + // special handling for the current makefile + if(mf == m_Makefile) + { + dir = "."; // no subdirectory for project generated + // if this is the special ALL_BUILD utility, then + // make it depend on every other non UTILITY project. + // This is done by adding the names to the GetUtilities + // vector on the makefile + if(l->first == "ALL_BUILD") + { + for(std::vector::iterator a = allListFiles.begin(); + a != allListFiles.end(); ++a) + { + const cmTargets &atgts = (*a)->GetTargets(); + for(cmTargets::const_iterator al = atgts.begin(); + al != atgts.end(); ++al) + { + if (al->second.IsInAll()) + { + if (al->second.GetType() == cmTarget::UTILITY) + { + l->second.AddUtility(al->first.c_str()); + } + else + { + l->second.GetLinkLibraries().push_back( + cmTarget::LinkLibraries::value_type(al->first, + cmTarget::GENERAL)); + } + } + } + } + } + } + // Write the project into the SLN file + if (strncmp(l->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) == 0) + { + cmCustomCommand cc = l->second.GetCustomCommands()[0]; + + // dodgy use of the cmCustomCommand's members to store the + // arguments from the INCLUDE_EXTERNAL_MSPROJECT command + std::vector stuff = cc.GetDepends(); + std::vector depends = cc.GetOutputs(); + this->WriteExternalProject(fout, stuff[0].c_str(), stuff[1].c_str(), depends); + ++si; + } + else if ((l->second.GetType() != cmTarget::INSTALL_FILES) + && (l->second.GetType() != cmTarget::INSTALL_PROGRAMS)) + { + this->WriteProject(fout, si->c_str(), dir.c_str(), + pg->GetVCProjWriter(),l->second); + ++si; + } + } + } + fout << "Global\n" + << "\tGlobalSection(SolutionConfiguration) = preSolution\n" + << "\t\tConfigName.0 = Debug\n" + << "\t\tConfigName.1 = MinSizeRel\n" + << "\t\tConfigName.2 = Release\n" + << "\t\tConfigName.3 = RelWithDebInfo\n" + << "\tEndGlobalSection\n" + << "\tGlobalSection(ProjectDependencies) = postSolution\n"; + // loop over again and compute the depends + for(k = allListFiles.begin(); k != allListFiles.end(); ++k) + { + cmMakefile* mf = *k; + cmMSDotNETGenerator* pg = + static_cast(mf->GetMakefileGenerator()); + // Get the list of create dsp files names from the cmVCProjWriter, more + // than one dsp could have been created per input CMakeLists.txt file + // for each target + std::vector dspnames = + pg->GetVCProjWriter()->GetCreatedProjectNames(); + cmTargets &tgts = pg->GetVCProjWriter()->GetMakefile()->GetTargets(); + cmTargets::iterator l = tgts.begin(); + std::string dir = mf->GetStartDirectory(); + for(std::vector::iterator si = dspnames.begin(); + l != tgts.end(); ++l) + { + if ((l->second.GetType() != cmTarget::INSTALL_FILES) + && (l->second.GetType() != cmTarget::INSTALL_PROGRAMS)) + { + this->WriteProjectDepends(fout, si->c_str(), dir.c_str(), + pg->GetVCProjWriter(),l->second); + ++si; + } + } + } + fout << "\tEndGlobalSection\n"; + fout << "\tGlobalSection(ProjectConfiguration) = postSolution\n"; + // loop over again and compute the depends + for(k = allListFiles.begin(); k != allListFiles.end(); ++k) + { + cmMakefile* mf = *k; + cmMSDotNETGenerator* pg = + static_cast(mf->GetMakefileGenerator()); + // Get the list of create dsp files names from the cmVCProjWriter, more + // than one dsp could have been created per input CMakeLists.txt file + // for each target + std::vector dspnames = + pg->GetVCProjWriter()->GetCreatedProjectNames(); + cmTargets &tgts = pg->GetVCProjWriter()->GetMakefile()->GetTargets(); + cmTargets::iterator l = tgts.begin(); + std::string dir = mf->GetStartDirectory(); + for(std::vector::iterator si = dspnames.begin(); + l != tgts.end(); ++l) + { + if ((l->second.GetType() != cmTarget::INSTALL_FILES) + && (l->second.GetType() != cmTarget::INSTALL_PROGRAMS)) + { + this->WriteProjectConfigurations(fout, si->c_str()); + ++si; + } + } + // delete the cmMakefile which also deletes the cmMSProjectGenerator + if(mf != m_Makefile) + { + delete mf; + } + } + fout << "\tEndGlobalSection\n"; + + // Write the footer for the SLN file + this->WriteSLNFooter(fout); +} + + +// Write a dsp file into the SLN file, +// Note, that dependencies from executables to +// the libraries it uses are also done here +void cmSLNWriter::WriteProject(std::ostream& fout, + const char* dspname, + const char* dir, + cmVCProjWriter*, + const cmTarget& target + ) +{ + std::string d = dir; + cmSystemTools::ConvertToWindowsSlashes(d); + fout << "Project(\"{" << this->CreateGUID(m_Makefile->GetProjectName()) + << "}\") = \"" << dspname << "\", \"" + << d << "\\" << dspname << ".vcproj\", \"{" + << this->CreateGUID(dspname) << "}\"\nEndProject\n"; +} + + + +// Write a dsp file into the SLN file, +// Note, that dependencies from executables to +// the libraries it uses are also done here +void cmSLNWriter::WriteProjectDepends(std::ostream& fout, + const char* dspname, + const char* dir, + cmVCProjWriter*, + const cmTarget& target + ) +{ + int depcount = 0; + // insert Begin Project Dependency Project_Dep_Name project stuff here + if (target.GetType() != cmTarget::STATIC_LIBRARY) + { + cmTarget::LinkLibraries::const_iterator j, jend; + j = target.GetLinkLibraries().begin(); + jend = target.GetLinkLibraries().end(); + for(;j!= jend; ++j) + { + if(j->first != dspname) + { + // is the library part of this SLN ? If so add dependency + const char* cacheValue + = m_Makefile->GetDefinition(j->first.c_str()); + if(cacheValue) + { + fout << "\t\t{" << this->CreateGUID(dspname) << "}." << depcount << " = {" + << this->CreateGUID(j->first.c_str()) << "}\n"; + depcount++; + } + } + } + } + + std::set::const_iterator i, end; + // write utility dependencies. + i = target.GetUtilities().begin(); + end = target.GetUtilities().end(); + for(;i!= end; ++i) + { + if(*i != dspname) + { + fout << "\t\t{" << this->CreateGUID(dspname) << "}." << depcount << " = {" + << this->CreateGUID(i->c_str()) << "}\n"; + depcount++; + } + } +} + + +// Write a dsp file into the SLN file, +// Note, that dependencies from executables to +// the libraries it uses are also done here +void cmSLNWriter::WriteProjectConfigurations(std::ostream& fout, const char* name) +{ + std::string guid = this->CreateGUID(name); + fout << "\t\t{" << guid << "}.Debug.ActiveCfg = Debug|Win32\n" + << "\t\t{" << guid << "}.Debug.Build.0 = Debug|Win32\n" + << "\t\t{" << guid << "}.MinSizeRel.ActiveCfg = Debug|Win32\n" + << "\t\t{" << guid << "}.MinSizeRel.Build.0 = Debug|Win32\n" + << "\t\t{" << guid << "}.Release.ActiveCfg = Debug|Win32\n" + << "\t\t{" << guid << "}.Release.Build.0 = Debug|Win32\n" + << "\t\t{" << guid << "}.RelWithDebInfo.ActiveCfg = Debug|Win32\n" + << "\t\t{" << guid << "}.RelWithDebInfo.Build.0 = Debug|Win32\n"; +} + + +// Write a dsp file into the SLN file, +// Note, that dependencies from executables to +// the libraries it uses are also done here +void cmSLNWriter::WriteExternalProject(std::ostream& fout, + const char* name, + const char* location, + const std::vector& dependencies) +{ + cmSystemTools::Error("WriteExternalProject not implemented"); +// fout << "#########################################################" +// "######################\n\n"; +// fout << "Project: \"" << name << "\"=" +// << location << " - Package Owner=<4>\n\n"; +// fout << "Package=<5>\n{{{\n}}}\n\n"; +// fout << "Package=<4>\n"; +// fout << "{{{\n"; + + +// std::vector::const_iterator i, end; +// // write dependencies. +// i = dependencies.begin(); +// end = dependencies.end(); +// for(;i!= end; ++i) +// { +// fout << "Begin Project Dependency\n"; +// fout << "Project_Dep_Name " << *i << "\n"; +// fout << "End Project Dependency\n"; +// } +// fout << "}}}\n\n"; +} + + + +// Standard end of dsw file +void cmSLNWriter::WriteSLNFooter(std::ostream& fout) +{ + fout << "\tGlobalSection(ExtensibilityGlobals) = postSolution\n" + << "\tEndGlobalSection\n" + << "\tGlobalSection(ExtensibilityAddIns) = postSolution\n" + << "\tEndGlobalSection\n" + << "EndGlobal\n"; +} + + +// ouput standard header for dsw file +void cmSLNWriter::WriteSLNHeader(std::ostream& fout) +{ + fout << "Microsoft Visual Studio Solution File, Format Version 7.00\n"; +} + + +std::string cmSLNWriter::CreateGUID(const char* name) +{ + std::map::iterator i = m_GUIDMap.find(name); + if(i != m_GUIDMap.end()) + { + return i->second; + } + std::string ret; + UUID uid; + unsigned char *uidstr; + UuidCreate(&uid); + UuidToString(&uid,&uidstr); + ret = reinterpret_cast(uidstr); + RpcStringFree(&uidstr); + m_GUIDMap[name] = ret; + return ret; +} diff --git a/Source/cmSLNWriter.h b/Source/cmSLNWriter.h new file mode 100644 index 0000000..91a3e59 --- /dev/null +++ b/Source/cmSLNWriter.h @@ -0,0 +1,62 @@ +/*========================================================================= + + Program: Insight Segmentation & Registration Toolkit + Module: $RCSfile$ + Language: C++ + Date: $Date$ + Version: $Revision$ + + Copyright (c) 2002 Insight Consortium. All rights reserved. + See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notices for more information. + +=========================================================================*/ +#ifndef cmSLNWriter_h +#define cmSLNWriter_h + +#include "cmStandardIncludes.h" +#include "cmMakefile.h" + +class cmVCProjWriter; + +/** \class cmSLNWriter + * \brief Write a Microsoft Visual C++ .NET SLN (workspace) file. + * + * cmSLNWriter produces a Microsoft Visual C++ .NET SLN (workspace) file. + */ +class cmSLNWriter +{ +public: + /** + * Constructor. + */ + cmSLNWriter(cmMakefile*); + + /** + * Generate the SLN workspace file. + */ + virtual void OutputSLNFile(); + +private: + std::string CreateGUID(const char* project); + void WriteSLNFile(std::ostream& fout); + void WriteSLNHeader(std::ostream& fout); + void WriteProject(std::ostream& fout, + const char* name, const char* path, + cmVCProjWriter* project, const cmTarget &t); + void WriteProjectDepends(std::ostream& fout, + const char* name, const char* path, + cmVCProjWriter* project, const cmTarget &t); + void WriteProjectConfigurations(std::ostream& fout, const char* name); + void WriteExternalProject(std::ostream& fout, + const char* name, const char* path, + const std::vector& dependencies); + void WriteSLNFooter(std::ostream& fout); + cmMakefile* m_Makefile; + std::map m_GUIDMap; +}; + +#endif diff --git a/Source/cmSystemTools.cxx b/Source/cmSystemTools.cxx index 6f7a071..fa639e3 100644 --- a/Source/cmSystemTools.cxx +++ b/Source/cmSystemTools.cxx @@ -784,15 +784,58 @@ bool cmSystemTools::FilesDiffer(const char* source, { return true; } - + const int buffer_length = 4096; + char bufferSource[buffer_length]; + char bufferDest[buffer_length]; while(finSource && finDestination) { - char s, d; - finSource >> s; - finDestination >> d; - if(s != d) + if(finSource.getline(bufferSource, buffer_length, '\n') + || finSource.gcount()) { - return true; + if(finDestination.getline(bufferDest, buffer_length, '\n') + || finDestination.gcount()) + { + // both if statements passed + if(finSource.eof()) + { + if(!finDestination.eof()) + { + return true; + } + if(finSource.gcount() != finDestination.gcount()) + { + return true; + } + if(strncmp(bufferSource, bufferDest, finSource.gcount()) != 0) + { + return true; + } + } + else if(finSource.fail()) + { + if(!finDestination.fail()) + { + return true; + } + if(strcmp(bufferSource, bufferDest) != 0) + { + return true; + } + finSource.clear(finSource.rdstate() & ~std::ios::failbit); + finDestination.clear(finDestination.rdstate() & ~std::ios::failbit); + } + else + { + if(strcmp(bufferSource, bufferDest) != 0) + { + return true; + } + } + } + else + { + return true; + } } } return false; diff --git a/Source/cmVCProjWriter.cxx b/Source/cmVCProjWriter.cxx new file mode 100644 index 0000000..764e29b --- /dev/null +++ b/Source/cmVCProjWriter.cxx @@ -0,0 +1,496 @@ +/*========================================================================= + + Program: Insight Segmentation & Registration Toolkit + Module: $RCSfile$ + Language: C++ + Date: $Date$ + Version: $Revision$ + + Copyright (c) 2002 Insight Consortium. All rights reserved. + See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notices for more information. + +=========================================================================*/ +#include "cmVCProjWriter.h" +#include "cmStandardIncludes.h" +#include "cmSystemTools.h" +#include "cmRegularExpression.h" + + +// TODO +// for CommandLine= need to repleace quotes with " +// write out configurations + +cmVCProjWriter::~cmVCProjWriter() +{ +} + + +cmVCProjWriter::cmVCProjWriter(cmMakefile*mf) +{ + m_Makefile = mf; + m_Configurations.push_back("Debug"); + m_Configurations.push_back("Release"); + m_Configurations.push_back("MinSizeRel"); + m_Configurations.push_back("RelWithDebInfo"); +} + +void cmVCProjWriter::OutputVCProjFile() +{ + // 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 VCProj file + std::vector& includes = m_Makefile->GetIncludeDirectories(); + std::vector::iterator i; + for(i = includes.begin(); i != includes.end(); ++i) + { + std::string tmp = cmSystemTools::EscapeSpaces(i->c_str()); + cmSystemTools::ConvertToWindowsSlashesAndCleanUp(tmp); + m_IncludeOptions += ","; + // quote if not already quoted + if (tmp[0] != '"') + { + m_IncludeOptions += tmp; + } + else + { + m_IncludeOptions += tmp; + } + } + + // Create the VCProj or set of VCProj's for libraries and executables + + // clear project names + m_CreatedProjectNames.clear(); + + // build any targets + 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; + } + // 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)) + { + this->CreateSingleVCProj(l->first.c_str(),l->second); + } + } +} + +void cmVCProjWriter::CreateSingleVCProj(const char *lname, cmTarget &target) +{ + // add to the list of projects + std::string pname = lname; + m_CreatedProjectNames.push_back(pname); + // create the dsp.cmake file + std::string fname; + fname = m_Makefile->GetStartOutputDirectory(); + fname += "/"; + fname += lname; + fname += ".vcproj"; + // save the name of the real dsp file + std::string realVCProj = fname; + fname += ".cmake"; + std::ofstream fout(fname.c_str()); + if(!fout) + { + cmSystemTools::Error("Error Writing ", fname.c_str()); + } + this->WriteVCProjFile(fout,lname,target); + fout.close(); + // if the dsp file has changed, then write it. + cmSystemTools::CopyFileIfDifferent(fname.c_str(), realVCProj.c_str()); +} + + +void cmVCProjWriter::AddVCProjBuildRule(cmSourceGroup& sourceGroup) +{ + std::string dspname = *(m_CreatedProjectNames.end()-1); + if(dspname == "ALL_BUILD") + { + return; + } + dspname += ".vcproj.cmake"; + std::string makefileIn = m_Makefile->GetStartDirectory(); + makefileIn += "/"; + makefileIn += "CMakeLists.txt"; + makefileIn = cmSystemTools::HandleNetworkPaths(makefileIn.c_str()); + makefileIn = cmSystemTools::EscapeSpaces(makefileIn.c_str()); + std::string dsprule = "${CMAKE_COMMAND}"; + m_Makefile->ExpandVariablesInString(dsprule); + dsprule = cmSystemTools::HandleNetworkPaths(dsprule.c_str()); + std::string args = makefileIn; + 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); + + std::string configFile = + m_Makefile->GetDefinition("CMAKE_ROOT"); + configFile += "/Templates/CMakeWindowsSystemConfig.cmake"; + std::vector listFiles = m_Makefile->GetListFiles(); + bool found = false; + for(std::vector::iterator i = listFiles.begin(); + i != listFiles.end(); ++i) + { + if(*i == configFile) + { + found = true; + } + } + if(!found) + { + listFiles.push_back(configFile); + } + + std::vector outputs; + outputs.push_back(dspname); + cmCustomCommand cc(makefileIn.c_str(), dsprule.c_str(), + args.c_str(), + listFiles, + outputs); + sourceGroup.AddCustomCommand(cc); +} + + +void cmVCProjWriter::WriteConfigurations(std::ostream& fout, + const char *libName, + const cmTarget &target) +{ + fout << "\t\n"; + + fout << "\t\n"; +} + + +void cmVCProjWriter::WriteVCProjFile(std::ostream& fout, + const char *libName, + cmTarget &target) +{ + // We may be modifying the source groups temporarily, so make a copy. + std::vector sourceGroups = m_Makefile->GetSourceGroups(); + + // get the classes from the source lists then add them to the groups + std::vector classes = target.GetSourceFiles(); + for(std::vector::iterator i = classes.begin(); + i != classes.end(); i++) + { + // Add the file to the list of sources. + 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::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); + } + + // open the project + this->WriteProjectStart(fout, libName, target, sourceGroups); + // write the configuration information + this->WriteConfigurations(fout, libName, target); + + fout << "\t\n"; + // Find the group in which the CMakeLists.txt source belongs, and add + // the rule to generate this VCProj file. + for(std::vector::reverse_iterator sg = sourceGroups.rbegin(); + sg != sourceGroups.rend(); ++sg) + { + if(sg->Matches("CMakeLists.txt")) + { + this->AddVCProjBuildRule(*sg); + break; + } + } + + + // Loop through every source group. + for(std::vector::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->WriteVCProjBeginGroup(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; + + if (source != libName || target.GetType() == cmTarget::UTILITY) + { + fout << "\t\t\t\n"; + if (!commands.empty()) + { + 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); + } + fout << "\t\t\t\n"; + } + } + + // If the group has a name, write the footer. + if(name != "") + { + this->WriteVCProjEndGroup(fout); + } + } + fout << "\t\n"; + + // Write the VCProj file's footer. + this->WriteVCProjFooter(fout); +} + + +void cmVCProjWriter::WriteCustomRule(std::ostream& fout, + const char* source, + const char* command, + const std::set& depends, + const std::set& outputs) +{ + std::string cmd = command; + cmSystemTools::ReplaceString(cmd, "\"", """); + std::vector::iterator i; + for(i = m_Configurations.begin(); i != m_Configurations.end(); ++i) + { + fout << "\t\t\t\t\n"; + fout << "\t\t\t\t\t::const_iterator d = depends.begin(); + d != depends.end(); ++d) + { + temp = *d; + fout << cmSystemTools::EscapeSpaces(cmSystemTools::ConvertToWindowsSlashes(temp)) + << ";"; + } + fout << "\"\n"; + fout << "\t\t\t\t\tOutputs=\""; + bool first = true; + // Write a rule for every output generated by this command. + for(std::set::const_iterator output = outputs.begin(); + output != outputs.end(); ++output) + { + if(!first) + { + fout << ";"; + } + else + { + first = true; + } + fout << output->c_str(); + } + fout << "\"/>\n"; + fout << "\t\t\t\t\n"; + } +} + + +void cmVCProjWriter::WriteVCProjBeginGroup(std::ostream& fout, + const char* group, + const char* filter) +{ + fout << "\t\t\n"; +} + + +void cmVCProjWriter::WriteVCProjEndGroup(std::ostream& fout) +{ + fout << "\t\t\n"; +} + + + + +void cmVCProjWriter::SetBuildType(BuildType b, const char *libName) +{ + +} + +std::string +cmVCProjWriter::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) + { + 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 +cmVCProjWriter::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::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 cmVCProjWriter::WriteProjectStart(std::ostream& fout, const char *libName, + const cmTarget &target, + std::vector &) +{ + fout << "\n" + << "\n" + << "\t\n" + << "\t\t\n" + << "\t\n"; +} + + +void cmVCProjWriter::WriteVCProjFooter(std::ostream& fout) +{ + fout << "\t\n" + << "\t\n" + << "\n"; +} diff --git a/Source/cmVCProjWriter.h b/Source/cmVCProjWriter.h new file mode 100644 index 0000000..3e0c9e6 --- /dev/null +++ b/Source/cmVCProjWriter.h @@ -0,0 +1,99 @@ +/*========================================================================= + + Program: Insight Segmentation & Registration Toolkit + Module: $RCSfile$ + Language: C++ + Date: $Date$ + Version: $Revision$ + + Copyright (c) 2002 Insight Consortium. All rights reserved. + See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notices for more information. + +=========================================================================*/ +#ifndef cmVCProjWriter_h +#define cmVCProjWriter_h + +#include "cmStandardIncludes.h" +#include "cmMakefile.h" + +/** \class cmVCProjWriter + * \brief Generate a Microsoft VCProj project file. + * + * cmVCProjWriter generates a Microsoft VCProj project file. + * See the *.dsptemplate files for information on the templates + * used for making the project files. + */ +class cmVCProjWriter +{ +public: + cmVCProjWriter(cmMakefile*); + ~cmVCProjWriter(); + void OutputVCProjFile(); + enum BuildType {STATIC_LIBRARY, DLL, EXECUTABLE, WIN32_EXECUTABLE, UTILITY}; + + /** + * Specify the type of the build: static, dll, or executable. + */ + void SetBuildType(BuildType,const char *name); + + /** + * Return array of created VCProj names in a STL vector. + * Each executable must have its own dsp. + */ + std::vector GetCreatedProjectNames() + { + return m_CreatedProjectNames; + } + + /** + * Return the makefile. + */ + cmMakefile* GetMakefile() + { + return m_Makefile; + } + +private: + std::string m_VCProjHeaderTemplate; + std::string m_VCProjFooterTemplate; + std::vector m_CreatedProjectNames; + + void CreateSingleVCProj(const char *lname, cmTarget &tgt); + void WriteVCProjFile(std::ostream& fout, const char *libName, + cmTarget &tgt); + void WriteVCProjBeginGroup(std::ostream& fout, + const char* group, + const char* filter); + void WriteVCProjEndGroup(std::ostream& fout); + + void WriteProjectStart(std::ostream& fout, const char *libName, + const cmTarget &tgt, std::vector &sgs); + void WriteConfigurations(std::ostream& fout, + const char *libName, + const cmTarget &tgt); + + void WriteVCProjFooter(std::ostream& fout); + void AddVCProjBuildRule(cmSourceGroup&); + void WriteCustomRule(std::ostream& fout, + const char* source, + const char* command, + const std::set& depends, + const std::set& outputs); + + std::string CreateTargetRules(const cmTarget &target, + const char *libName); + std::string CombineCommands(const cmSourceGroup::Commands &commands, + cmSourceGroup::CommandFiles &totalCommand, + const char *source); + + + std::string m_IncludeOptions; + cmMakefile* m_Makefile; + std::vector m_Configurations; +}; + +#endif diff --git a/Source/cmake.cxx b/Source/cmake.cxx index 4020760..c2cec36 100644 --- a/Source/cmake.cxx +++ b/Source/cmake.cxx @@ -20,6 +20,7 @@ // include the generator #if defined(_WIN32) && !defined(__CYGWIN__) #include "cmMSProjectGenerator.h" +#include "cmMSDotNETGenerator.h" #include "cmBorlandMakefileGenerator.h" #include "cmNMakeMakefileGenerator.h" #else @@ -31,6 +32,7 @@ cmake::cmake() m_Verbose = false; #if defined(_WIN32) && !defined(__CYGWIN__) cmMakefileGenerator::RegisterGenerator(new cmMSProjectGenerator); + cmMakefileGenerator::RegisterGenerator(new cmMSDotNETGenerator); cmMakefileGenerator::RegisterGenerator(new cmNMakeMakefileGenerator); cmMakefileGenerator::RegisterGenerator(new cmBorlandMakefileGenerator); #else diff --git a/Source/cmake.dsp b/Source/cmake.dsp index 596e21a..ac9ca7d 100644 --- a/Source/cmake.dsp +++ b/Source/cmake.dsp @@ -76,7 +76,7 @@ BSC32=bscmake.exe # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept -# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /pdb:"cmake.pdb" /debug /machine:I386 /out:"cmake.exe" /pdbtype:sept +# ADD LINK32 rpcrt4.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /pdb:"cmake.pdb" /debug /machine:I386 /out:"cmake.exe" /pdbtype:sept # SUBTRACT LINK32 /pdb:none !ENDIF -- cgit v0.12