CMake/Source/cmExtraSublimeTextGenerator...

538 lines
19 KiB
C++
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2004-2009 Kitware, Inc.
Copyright 2004 Alexander Neundorf (neundorf@kde.org)
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#include "cmExtraSublimeTextGenerator.h"
#include "cmGlobalUnixMakefileGenerator3.h"
#include "cmLocalUnixMakefileGenerator3.h"
#include "cmMakefile.h"
#include "cmake.h"
#include "cmSourceFile.h"
#include "cmGeneratedFileStream.h"
#include "cmTarget.h"
#include "cmSystemTools.h"
#include "cmXMLSafe.h"
#include <cmsys/SystemTools.hxx>
#if defined(_WIN32)
# define PATH_SEP "\\"
#else
# define PATH_SEP "/"
#endif
/* Some useful URLs:
Homepage:
http://www.sublimetext.com/
File format docs:
http://www.sublimetext.com/docs/2/projects.html
http://sublimetext.info/docs/en/reference/build_systems.html
*/
//----------------------------------------------------------------------------
void cmExtraSublimeTextGenerator
::GetDocumentation(cmDocumentationEntry& entry, const char*) const
{
entry.Name = this->GetName();
entry.Brief = "Generates Sublime Text 2 project files.";
entry.Full =
"Project files for Sublime Text 2 will be created in the top directory "
"and in every subdirectory which features a CMakeLists.txt file "
"containing a PROJECT() call. "
"Additionally a hierarchy of makefiles is generated into the "
"build tree. The appropriate make program can build the project through "
"the default make target. A \"make install\" target is also provided.";
}
cmExtraSublimeTextGenerator::cmExtraSublimeTextGenerator()
:cmExternalMakefileProjectGenerator()
{
#if defined(_WIN32)
this->SupportedGlobalGenerators.push_back("MinGW Makefiles");
this->SupportedGlobalGenerators.push_back("NMake Makefiles");
// disable until somebody actually tests it:
// this->SupportedGlobalGenerators.push_back("MSYS Makefiles");
#endif
this->SupportedGlobalGenerators.push_back("Ninja");
this->SupportedGlobalGenerators.push_back("Unix Makefiles");
}
void cmExtraSublimeTextGenerator::Generate()
{
// for each sub project in the project create a sublime text 2 project
for (std::map<cmStdString, std::vector<cmLocalGenerator*> >::const_iterator
it = this->GlobalGenerator->GetProjectMap().begin();
it!= this->GlobalGenerator->GetProjectMap().end();
++it)
{
// create a project file
this->CreateProjectFile(it->second);
}
}
/* create the project file */
void cmExtraSublimeTextGenerator::CreateProjectFile(
const std::vector<cmLocalGenerator*>& lgs)
{
const cmMakefile* mf=lgs[0]->GetMakefile();
std::string outputDir=mf->GetStartOutputDirectory();
std::string projectName=mf->GetProjectName();
std::string filename=outputDir+"/";
filename+=projectName+".sublime-project";
this->CreateNewProjectFile(lgs, filename);
}
void cmExtraSublimeTextGenerator
::CreateNewProjectFile(const std::vector<cmLocalGenerator*>& lgs,
const std::string& filename)
{
const cmMakefile* mf=lgs[0]->GetMakefile();
cmGeneratedFileStream fout(filename.c_str());
if(!fout)
{
return;
}
// Collect all files, this includes source files and list files
std::vector<std::string> allFiles;
GetFileList(lgs, allFiles);
// A set of folders to include in the project
std::set<std::string> folderIncludePatternsSet;
std::stringstream fileIncludePatternsStream;
GetFileStringAndFolderSet(lgs, mf, allFiles, fileIncludePatternsStream,
folderIncludePatternsSet);
// Write the folder entries to the project file
const std::string &homeRelative = cmSystemTools::RelativePath(
lgs[0]->GetMakefile()->GetHomeOutputDirectory(),
lgs[0]->GetMakefile()->GetHomeDirectory());
fout << "{\n";
fout << "\t\"folders\":\n\t[\n\t";
fout << "\t{\n\t\t\t\"path\": \"" << homeRelative << "\",\n";
fout << "\t\t\t\"folder_include_patterns\": [";
std::set<std::string>::const_iterator folderIter =
folderIncludePatternsSet.begin();
while (folderIter != folderIncludePatternsSet.end())
{
fout << "\"" << *folderIter << "\"";
folderIter++;
if (folderIter != folderIncludePatternsSet.end())
{
fout << ", ";
}
}
fout << "],\n";
fout << "\t\t\t\"file_include_patterns\": [" <<
fileIncludePatternsStream.str() << "]\n";
fout << "\t\t},\n\t";
// In order for SublimeClang's path resolution to work, the directory that
// contains the sublime-project file must be included here. We just ensure
// that no files or subfolders are included
fout << "\t{\n\t\t\t\"path\": \"./\",\n";
fout << "\t\t\t\"folder_exclude_patterns\": [\"*\"],\n";
fout << "\t\t\t\"file_exclude_patterns\": [\"*\"]\n";
fout << "\t\t}\n\t";
// End of the folders section
fout << "]";
// Write the beginning of the build systems section to the project file
fout << ",\n\t\"build_systems\":\n\t[\n\t";
// Set of include directories over all targets (sublime text/sublimeclang
// doesn't currently support these settings per build system, only project
// wide
std::set<std::string> includeDirs;
std::set<std::string> defines;
AppendAllTargets(lgs, mf, fout, includeDirs, defines);
// End of build_systems
fout << "\n\t]";
// Write the settings section with sublimeclang options
fout << ",\n\t\"settings\":\n\t{\n\t";
fout << "\t\"sublimeclang_options\":\n\t\t[\n\t\t";
std::set<std::string>::const_iterator stringSetIter = includeDirs.begin();
while (stringSetIter != includeDirs.end())
{
const std::string &includeDir = *stringSetIter;
const std::string &relative = cmSystemTools::RelativePath(
lgs[0]->GetMakefile()->GetHomeOutputDirectory(),
includeDir.c_str());
// It appears that a relative path to the sublime-project file doesn't
// always work. So we use ${folder:${project_path:<project_filename>}}
// that SublimeClang will expand to the correct path
fout << "\t\"-I${folder:${project_path:" << mf->GetProjectName() <<
".sublime-project}}/" << relative << "\"";
stringSetIter++;
if ((stringSetIter != includeDirs.end()) || (!defines.empty()))
{
fout << ",";
}
fout << "\n\t\t";
}
stringSetIter = defines.begin();
while (stringSetIter != defines.end())
{
fout << "\t\"-D" << *stringSetIter << "\"";
stringSetIter++;
if (stringSetIter != defines.end())
{
fout << ",";
}
fout << "\n\t\t";
}
// End of the sublimeclang_options section
fout << "]\n\t";
// End of the settings section
fout << "}\n";
// End of file
fout << "}";
}
// Get a list of all files and a set of all directories and subdirectories
// with source files
void cmExtraSublimeTextGenerator
::GetFileList(const std::vector<cmLocalGenerator*>& lgs,
std::vector<std::string>& allFiles)
{
for (std::vector<cmLocalGenerator *>::const_iterator
it = lgs.begin();
it != lgs.end();
++it)
{
cmMakefile* makefile=(*it)->GetMakefile();
// Add list files
const std::vector<std::string> & listFiles =
makefile->GetListFiles();
allFiles.insert(allFiles.end(), listFiles.begin(), listFiles.end());
// Add source files
cmTargets& targets=makefile->GetTargets();
for (cmTargets::iterator ti = targets.begin();
ti != targets.end(); ti++)
{
switch(ti->second.GetType())
{
case cmTarget::EXECUTABLE:
case cmTarget::STATIC_LIBRARY:
case cmTarget::SHARED_LIBRARY:
case cmTarget::MODULE_LIBRARY:
case cmTarget::OBJECT_LIBRARY:
case cmTarget::UTILITY: // can have sources since 2.6.3
{
const std::vector<cmSourceFile*>&sources=ti->second.GetSourceFiles();
for (std::vector<cmSourceFile*>::const_iterator si=sources.begin();
si!=sources.end(); si++)
{
// don't add source files which have the GENERATED property set:
if ((*si)->GetPropertyAsBool("GENERATED"))
{
continue;
}
allFiles.push_back((*si)->GetFullPath());
}
}
default: // intended fallthrough
break;
}
}
}
}
void cmExtraSublimeTextGenerator::
GetFileStringAndFolderSet(const std::vector<cmLocalGenerator*>& lgs,
const cmMakefile* mf,
const std::vector<std::string>& allFiles,
std::stringstream& fileIncludePatternsStream,
std::set<std::string>& folderIncludePatternsSet)
{
// Convert
const char* cmakeRoot = mf->GetDefinition("CMAKE_ROOT");
for (std::vector<std::string>::const_iterator jt = allFiles.begin();
jt != allFiles.end();
++jt)
{
// don't put cmake's own files into the project (#12110):
if (jt->find(cmakeRoot) == 0)
{
continue;
}
const std::string &relative = cmSystemTools::RelativePath(
lgs[0]->GetMakefile()->GetHomeDirectory(),
jt->c_str());
// Split filename from path
std::string fileName = cmSystemTools::GetFilenameName(relative);
std::string path = "";
if (fileName.length() < relative.length())
{
path = relative.substr(0, relative.length() - fileName.length() - 1);
}
// We don't want paths with CMakeFiles in them
if (relative.find("CMakeFiles") == std::string::npos)
{
if (fileIncludePatternsStream.tellp() > 0)
{
fileIncludePatternsStream << ", ";
}
fileIncludePatternsStream << "\"" << relative << "\"";
if ((!path.empty()) && (folderIncludePatternsSet.find(path) ==
folderIncludePatternsSet.end()))
{
folderIncludePatternsSet.insert(path);
std::string::size_type splitIndex = path.rfind(PATH_SEP);
std::string splitPath = path;
while (splitIndex != std::string::npos)
{
splitPath = splitPath.substr(0, splitIndex);
if ((splitPath.empty()) ||
(folderIncludePatternsSet.insert(splitPath).second == false))
{
// If the path is already in the set then all of its
// parents are as well
break;
}
splitIndex = splitPath.rfind(PATH_SEP);
}
}
}
}
}
void cmExtraSublimeTextGenerator::
AppendAllTargets(const std::vector<cmLocalGenerator*>& lgs,
const cmMakefile* mf,
cmGeneratedFileStream& fout,
std::set<std::string>& includeDirs,
std::set<std::string>& defines)
{
std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
std::string compiler = "";
this->AppendTarget(fout, "all", 0, make.c_str(), mf, compiler.c_str(),
includeDirs, defines, true);
this->AppendTarget(fout, "clean", 0, make.c_str(), mf, compiler.c_str(),
includeDirs, defines, false);
// add all executable and library targets and some of the GLOBAL
// and UTILITY targets
for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin();
lg!=lgs.end(); lg++)
{
cmMakefile* makefile=(*lg)->GetMakefile();
cmTargets& targets=makefile->GetTargets();
for (cmTargets::iterator ti = targets.begin();
ti != targets.end(); ti++)
{
switch(ti->second.GetType())
{
case cmTarget::GLOBAL_TARGET:
{
bool insertTarget = false;
// Only add the global targets from CMAKE_BINARY_DIR,
// not from the subdirs
if (strcmp(makefile->GetStartOutputDirectory(),
makefile->GetHomeOutputDirectory())==0)
{
insertTarget = true;
// only add the "edit_cache" target if it's not ccmake, because
// this will not work within the IDE
if (ti->first == "edit_cache")
{
const char* editCommand = makefile->GetDefinition
("CMAKE_EDIT_COMMAND");
if (editCommand == 0)
{
insertTarget = false;
}
else if (strstr(editCommand, "ccmake")!=NULL)
{
insertTarget = false;
}
}
}
if (insertTarget)
{
this->AppendTarget(fout, ti->first.c_str(), 0,
make.c_str(), makefile, compiler.c_str(),
includeDirs, defines, false);
}
}
break;
case cmTarget::UTILITY:
// Add all utility targets, except the Nightly/Continuous/
// Experimental-"sub"targets as e.g. NightlyStart
if (((ti->first.find("Nightly")==0) &&(ti->first!="Nightly"))
|| ((ti->first.find("Continuous")==0)&&(ti->first!="Continuous"))
|| ((ti->first.find("Experimental")==0)
&& (ti->first!="Experimental")))
{
break;
}
this->AppendTarget(fout, ti->first.c_str(), 0,
make.c_str(), makefile, compiler.c_str(),
includeDirs, defines, false);
break;
case cmTarget::EXECUTABLE:
case cmTarget::STATIC_LIBRARY:
case cmTarget::SHARED_LIBRARY:
case cmTarget::MODULE_LIBRARY:
case cmTarget::OBJECT_LIBRARY:
{
this->AppendTarget(fout, ti->first.c_str(), &ti->second,
make.c_str(), makefile, compiler.c_str(),
includeDirs, defines, false);
std::string fastTarget = ti->first;
fastTarget += "/fast";
this->AppendTarget(fout, fastTarget.c_str(), &ti->second,
make.c_str(), makefile, compiler.c_str(),
includeDirs, defines, false);
}
break;
default:
break;
}
}
}
}
// Generate the build_system entry for one target
void cmExtraSublimeTextGenerator::AppendTarget(cmGeneratedFileStream& fout,
const char* targetName,
cmTarget* target,
const char* make,
const cmMakefile* makefile,
const char* compiler,
std::set<std::string>&
includeDirs,
std::set<std::string>& defines,
bool firstTarget)
{
if (target != 0)
{
// the compilerdefines for this target
cmGeneratorTarget *gtgt = this->GlobalGenerator
->GetGeneratorTarget(target);
std::string cdefs = gtgt->GetCompileDefinitions();
if(!cdefs.empty())
{
// Expand the list.
std::vector<std::string> defs;
cmSystemTools::ExpandListArgument(cdefs.c_str(), defs);
for(std::vector<std::string>::const_iterator di = defs.begin();
di != defs.end(); ++di)
{
cmXMLSafe safedef(di->c_str());
defines.insert(safedef.str());
}
}
// the include directories for this target
std::vector<std::string> includes;
target->GetMakefile()->GetLocalGenerator()->
GetIncludeDirectories(includes, gtgt);
for(std::vector<std::string>::const_iterator dirIt=includes.begin();
dirIt != includes.end();
++dirIt)
{
includeDirs.insert(*dirIt);
}
std::string systemIncludeDirs = makefile->GetSafeDefinition(
"CMAKE_EXTRA_GENERATOR_C_SYSTEM_INCLUDE_DIRS");
if (!systemIncludeDirs.empty())
{
std::vector<std::string> dirs;
cmSystemTools::ExpandListArgument(systemIncludeDirs.c_str(), dirs);
for(std::vector<std::string>::const_iterator dirIt=dirs.begin();
dirIt != dirs.end();
++dirIt)
{
includeDirs.insert(*dirIt);
}
}
systemIncludeDirs = makefile->GetSafeDefinition(
"CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_INCLUDE_DIRS");
if (!systemIncludeDirs.empty())
{
std::vector<std::string> dirs;
cmSystemTools::ExpandListArgument(systemIncludeDirs.c_str(), dirs);
for(std::vector<std::string>::const_iterator dirIt=dirs.begin();
dirIt != dirs.end();
++dirIt)
{
includeDirs.insert(*dirIt);
}
}
}
// Write out the build_system data for this target
std::string makefileName = makefile->GetStartOutputDirectory();
makefileName += "/Makefile";
if (!firstTarget)
{
fout << ",\n\t";
}
fout << "\t{\n\t\t\t\"name\": \"" << makefile->GetProjectName() << " - " <<
targetName << "\",\n";
fout << "\t\t\t\"cmd\": [" <<
this->BuildMakeCommand(make, makefileName.c_str(), targetName) <<
"],\n";
fout << "\t\t\t\"working_dir\": \"${project_path}\",\n";
fout << "\t\t\t\"file_regex\": \"^(..[^:]*):([0-9]+):?([0-9]+)?:? (.*)$\"\n";
fout << "\t\t}";
}
// Create the command line for building the given target using the selected
// make
std::string cmExtraSublimeTextGenerator::BuildMakeCommand(
const std::string& make, const char* makefile, const char* target)
{
std::string command = "\"";
command += make + "\"";
if (strcmp(this->GlobalGenerator->GetName(), "NMake Makefiles")==0)
{
std::string makefileName = cmSystemTools::ConvertToOutputPath(makefile);
command += ", \"/NOLOGO\", \"/f\", \"";
command += makefileName + "\"";
command += ", \"VERBOSE=1\", \"";
command += target;
command += "\"";
}
else if (strcmp(this->GlobalGenerator->GetName(), "MinGW Makefiles")==0)
{
// no escaping of spaces in this case, see
// http://public.kitware.com/Bug/view.php?id=10014
std::string makefileName = makefile;
command += ", \"-f\", \"";
command += makefileName + "\"";
command += ", \"VERBOSE=1\", \"";
command += target;
command += "\"";
}
else
{
std::string makefileName = cmSystemTools::ConvertToOutputPath(makefile);
command += ", \"-f\", \"";
command += makefileName + "\"";
command += ", \"VERBOSE=1\", \"";
command += target;
command += "\"";
}
return command;
}