diff --git a/Source/cmGlobalCodeWarriorGenerator.cxx b/Source/cmGlobalCodeWarriorGenerator.cxx new file mode 100644 index 000000000..9e08bc99b --- /dev/null +++ b/Source/cmGlobalCodeWarriorGenerator.cxx @@ -0,0 +1,282 @@ +/*========================================================================= + + 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 "cmGlobalCodeWarriorGenerator.h" +#include "cmLocalCodeWarriorGenerator.h" +#include "cmMakefile.h" +#include "cmake.h" +#include "cmTarget.h" +#include "windows.h" + +void cmGlobalCodeWarriorGenerator::EnableLanguage(const char*, + cmMakefile *mf) +{ + // now load the settings + if(!mf->GetDefinition("CMAKE_ROOT")) + { + cmSystemTools::Error( + "CMAKE_ROOT has not been defined, bad GUI or driver program"); + return; + } + if(!this->GetLanguageEnabled("CXX")) + { + std::string fpath = + mf->GetDefinition("CMAKE_ROOT"); + fpath += "/Templates/CMakeDotNetSystemConfig.cmake"; + mf->ReadListFile(NULL,fpath.c_str()); + this->SetLanguageEnabled("CXX"); + } +} + +int cmGlobalCodeWarriorGenerator::TryCompile(const char *, + const char *bindir, + const char *projectName, + const char *targetName, + std::string *output) +{ + return 1; +} + +///! Create a local generator appropriate to this Global Generator +cmLocalGenerator *cmGlobalCodeWarriorGenerator::CreateLocalGenerator() +{ + cmLocalGenerator *lg = new cmLocalCodeWarriorGenerator; + lg->SetGlobalGenerator(this); + return lg; +} + +void cmGlobalCodeWarriorGenerator::Generate() +{ + // first do the superclass method + this->cmGlobalGenerator::Generate(); + + // Now write out the Project File + this->OutputProject(); +} + +void cmGlobalCodeWarriorGenerator::OutputProject() +{ + // if this is an out of source build, create the output directory + if(strcmp(m_CMakeInstance->GetStartOutputDirectory(), + m_CMakeInstance->GetHomeDirectory()) != 0) + { + if(!cmSystemTools::MakeDirectory(m_CMakeInstance->GetStartOutputDirectory())) + { + cmSystemTools::Error("Error creating output directory for Project file", + m_CMakeInstance->GetStartOutputDirectory()); + } + } + // create the project file name + std::string fname; + fname = m_CMakeInstance->GetStartOutputDirectory(); + fname += "/"; + if(strlen(m_LocalGenerators[0]->GetMakefile()->GetProjectName()) == 0) + { + m_LocalGenerators[0]->GetMakefile()->SetProjectName("Project"); + } + fname += m_LocalGenerators[0]->GetMakefile()->GetProjectName(); + fname += ".xml"; + std::ofstream fout(fname.c_str()); + if(!fout) + { + cmSystemTools::Error("Error can not open project file for write: " + ,fname.c_str()); + return; + } + this->WriteProject(fout); +} + +void cmGlobalCodeWarriorGenerator::WriteProject(std::ostream& fout) +{ + // Write out the header for a SLN file + this->WriteProjectHeader(fout); + + // start the project + fout << "\n"; + + // write the target list + this->WriteTargetList(fout); + + // write the target order + this->WriteTargetOrder(fout); + + // write the group list + this->WriteGroupList(fout); + + // close the project + fout << "\n"; +} + +void cmGlobalCodeWarriorGenerator::WriteProjectHeader(std::ostream& fout) +{ + fout << "\n"; + fout << "\n"; + + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "\n"; + fout << "]>\n\n"; +} + +void cmGlobalCodeWarriorGenerator::WriteTargetList(std::ostream& fout) +{ + fout << "\n"; + + unsigned int i; + // for each local generator + for (i = 0; i < m_LocalGenerators.size(); ++i) + { + static_cast(m_LocalGenerators[i])->WriteTargets(fout); + } + fout << "\n"; +} + +cmTarget *cmGlobalCodeWarriorGenerator::GetTargetFromName(const char *tgtName) +{ + // for each local generator, and each target + unsigned int i; + for(i = 0; i < m_LocalGenerators.size(); ++i) + { + cmMakefile* mf = m_LocalGenerators[i]->GetMakefile(); + cmTargets &tgts = mf->GetTargets(); + for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l) + { + if (l->first == tgtName) + { + return &(l->second); + } + } + } + return 0; +} + +void cmGlobalCodeWarriorGenerator::ComputeTargetOrder( + std::vector &tgtOrder, const char *tgtName, + cmTarget const *target) +{ + // if the target is already listed then we are done + if (std::find(tgtOrder.begin(),tgtOrder.end(),tgtName) != tgtOrder.end()) + { + return; + } + + // otherwise find all this target depends on and add them first + cmTarget::LinkLibraries::const_iterator j, jend; + j = target->GetLinkLibraries().begin(); + jend = target->GetLinkLibraries().end(); + for(;j!= jend; ++j) + { + if(j->first != tgtName) + { + // is the library part of this Project ? + std::string libPath = j->first + "_CMAKE_PATH"; + const char* cacheValue + = m_CMakeInstance->GetCacheDefinition(libPath.c_str()); + if(cacheValue) + { + // so add it to the tgtOrder vector if it isn't already there + // to do this we need the actual target + cmTarget *tgt = this->GetTargetFromName(j->first.c_str()); + this->ComputeTargetOrder(tgtOrder,j->first.c_str(), tgt); + } + } + } + // finally add the target + tgtOrder.push_back(tgtName); +} + +void cmGlobalCodeWarriorGenerator::WriteTargetOrder(std::ostream& fout) +{ + fout << "\n"; + + std::vector tgtOrder; + unsigned int i; + // for each local generator, and each target + for(i = 0; i < m_LocalGenerators.size(); ++i) + { + cmMakefile* mf = m_LocalGenerators[i]->GetMakefile(); + cmTargets &tgts = mf->GetTargets(); + for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l) + { + this->ComputeTargetOrder(tgtOrder, l->first.c_str(), &(l->second)); + } + } + + // now write out the target order + for(i = 0; i < tgtOrder.size(); ++i) + { + fout << "" << tgtOrder[i] + << "\n"; + } + fout << "\n"; +} + +void cmGlobalCodeWarriorGenerator::WriteGroupList(std::ostream& fout) +{ + fout << "\n"; + + fout << "\n"; +} + +void cmGlobalCodeWarriorGenerator::LocalGenerate() +{ + this->cmGlobalGenerator::LocalGenerate(); +} diff --git a/Source/cmGlobalCodeWarriorGenerator.h b/Source/cmGlobalCodeWarriorGenerator.h new file mode 100644 index 000000000..884e4b46e --- /dev/null +++ b/Source/cmGlobalCodeWarriorGenerator.h @@ -0,0 +1,84 @@ +/*========================================================================= + + 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 cmGlobalCodeWarriorGenerator_h +#define cmGlobalCodeWarriorGenerator_h + +#include "cmGlobalGenerator.h" + +class cmTarget; + +/** \class cmGlobalCodeWarriorGenerator + * \brief Write a Unix makefiles. + * + * cmGlobalCodeWarriorGenerator manages UNIX build process for a tree + */ +class cmGlobalCodeWarriorGenerator : public cmGlobalGenerator +{ +public: + ///! Get the name for the generator. + virtual const char* GetName() { + return cmGlobalCodeWarriorGenerator::GetActualName();} + static const char* GetActualName() {return "Code Warrior";} + + ///! Create a local generator appropriate to this Global Generator + virtual cmLocalGenerator *CreateLocalGenerator(); + + /** + * Try to determine system infomation such as shared library + * extension, pthreads, byte order etc. + */ + virtual void EnableLanguage(const char*, cmMakefile *mf); + + /** + * Try running cmake and building a file. This is used for dynalically + * loaded commands, not as part of the usual build process. + */ + virtual int TryCompile(const char *srcdir, const char *bindir, + const char *projectName, const char *targetName, + std::string *output); + + /** + * Generate the all required files for building this project/tree. This + * basically creates a series of LocalGenerators for each directory and + * requests that they Generate. + */ + virtual void Generate(); + + /** + * Generate the required files for building this directory. This + * basically creates a single LocalGenerators and + * requests that it Generate. + */ + virtual void LocalGenerate(); + + /** + * Generate the DSW workspace file. + */ + virtual void OutputProject(); + +private: + cmTarget *GetTargetFromName(const char *tgtName); + void WriteProject(std::ostream & fout); + void WriteProjectHeader(std::ostream & fout); + void WriteTargetList(std::ostream & fout); + void WriteTargetOrder(std::ostream & fout); + void WriteGroupList(std::ostream & fout); + void ComputeTargetOrder(std::vector &tgtOrder, + const char *tgtName, cmTarget const *tgt); +}; + +#endif diff --git a/Source/cmLocalCodeWarriorGenerator.cxx b/Source/cmLocalCodeWarriorGenerator.cxx new file mode 100644 index 000000000..e0bcaf1d1 --- /dev/null +++ b/Source/cmLocalCodeWarriorGenerator.cxx @@ -0,0 +1,118 @@ +/*========================================================================= + + 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 "cmGlobalCodeWarriorGenerator.h" +#include "cmLocalCodeWarriorGenerator.h" +#include "cmMakefile.h" +#include "cmSystemTools.h" +#include "cmSourceFile.h" +#include "cmCacheManager.h" + +cmLocalCodeWarriorGenerator::cmLocalCodeWarriorGenerator() +{ +} + +cmLocalCodeWarriorGenerator::~cmLocalCodeWarriorGenerator() +{ +} + + +void cmLocalCodeWarriorGenerator::Generate(bool /* fromTheTop */) +{ + +} + +void cmLocalCodeWarriorGenerator::WriteTargets(std::ostream& fout) +{ + cmTargets &tgts = m_Makefile->GetTargets(); + for(cmTargets::iterator l = tgts.begin(); + l != tgts.end(); l++) + { + this->WriteTarget(fout,l->first.c_str(),&(l->second)); + } +} + +void cmLocalCodeWarriorGenerator::WriteTarget(std::ostream& fout, + const char *tgtName, + cmTarget const *l) +{ + fout << "\n"; + fout << "" << tgtName << "\n"; + + this->WriteSettingList(fout,tgtName,l); + this->WriteFileList(fout,tgtName,l); + // this->WriteLinkOrder(fout,l); + // this->WriteSubTargetList(fout,l); + + fout << "\n"; +} + +void cmLocalCodeWarriorGenerator::WriteSettingList(std::ostream& fout, + const char *tgtName, + cmTarget const *l) +{ + fout << "\n"; + + // list the include paths + fout << "UserSearchPaths\n"; + std::vector& includes = m_Makefile->GetIncludeDirectories(); + std::vector::iterator i = includes.begin(); + for(;i != includes.end(); ++i) + { + fout << "\n"; + fout << "SearchPath\n"; + fout << "Path" << i->c_str() << "\n"; + fout << "PathFormatGeneric\n"; + fout << "PathRootAbsolute\n"; + fout << "\n"; + fout << "Recursivefalse\n"; + fout << "FrameworkPathfalse\n"; + fout << "HostFlagsAll\n"; + fout << "\n"; + } + fout << "\n"; + + fout << "Targetname" << tgtName + << "\n"; + + fout << "\n"; +} + +void cmLocalCodeWarriorGenerator::WriteFileList(std::ostream& fout, + const char *tgtName, + cmTarget const *l) +{ + fout << "\n"; + + // for each file + std::vector const& classes = l->GetSourceFiles(); + for(std::vector::const_iterator i = classes.begin(); + i != classes.end(); i++) + { + // Add the file to the list of sources. + std::string source = (*i)->GetFullPath(); + fout << "\n"; + fout << "PathAbsolute\n"; + fout << "Absolute\n"; + //fout << "common\n"; + fout << "" << source << "\n"; + fout << "Generic\n"; + fout << "Text\n"; + fout << "Debug\n"; + fout << "\n"; + } + fout << "\n"; +} diff --git a/Source/cmLocalCodeWarriorGenerator.h b/Source/cmLocalCodeWarriorGenerator.h new file mode 100644 index 000000000..5987fb841 --- /dev/null +++ b/Source/cmLocalCodeWarriorGenerator.h @@ -0,0 +1,69 @@ +/*========================================================================= + + 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 cmLocalCodeWarriorGenerator_h +#define cmLocalCodeWarriorGenerator_h + +#include "cmLocalGenerator.h" + +class cmMakeDepend; +class cmTarget; +class cmSourceFile; + +// please remove me.... Yuck +#include "cmSourceGroup.h" + +/** \class cmLocalCodeWarriorGenerator + * \brief Write a LocalUnix makefiles. + * + * cmLocalCodeWarriorGenerator produces a LocalUnix makefile from its + * member m_Makefile. + */ +class cmLocalCodeWarriorGenerator : public cmLocalGenerator +{ +public: + ///! Set cache only and recurse to false by default. + cmLocalCodeWarriorGenerator(); + + virtual ~cmLocalCodeWarriorGenerator(); + + /** + * Generate the makefile for this directory. fromTheTop indicates if this + * is being invoked as part of a global Generate or specific to this + * directory. The difference is that when done from the Top we might skip + * some steps to save time, such as dependency generation for the + * makefiles. This is done by a direct invocation from make. + */ + virtual void Generate(bool fromTheTop); + + 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); + + void WriteTargets(std::ostream& fout); + +private: + void WriteTarget(std::ostream& fout, const char *name, cmTarget const *l); + void WriteSettingList(std::ostream& fout, const char *name, + cmTarget const *l); + void WriteFileList(std::ostream& fout, const char *name, cmTarget const *l); +}; + +#endif +