635 lines
17 KiB
C++
635 lines
17 KiB
C++
#include "SolutionParserVisualStudio.h"
|
|
|
|
#include <algorithm>
|
|
#include <cstdlib>
|
|
#include <set>
|
|
|
|
#include "boost/filesystem/path.hpp"
|
|
#include "boost/filesystem.hpp"
|
|
|
|
#include "SolutionParserUtility.h"
|
|
|
|
#include "utility/logging/logging.h"
|
|
|
|
SolutionParserVisualStudio::SolutionParserVisualStudio()
|
|
: m_compatibilityFlags()
|
|
{
|
|
m_compatibilityFlags.push_back("-fms-extensions");
|
|
m_compatibilityFlags.push_back("-fms-compatibility");
|
|
m_compatibilityFlags.push_back("-fms-compatibility-version=19.00");
|
|
|
|
SolutionParserUtility::m_ideMacros.clear();
|
|
|
|
SolutionParserUtility::m_ideMacros.push_back("RemoteMachine");
|
|
SolutionParserUtility::m_ideMacros.push_back("Configuration");
|
|
SolutionParserUtility::m_ideMacros.push_back("Platform");
|
|
SolutionParserUtility::m_ideMacros.push_back("ParentName");
|
|
SolutionParserUtility::m_ideMacros.push_back("RootNameSpace");
|
|
SolutionParserUtility::m_ideMacros.push_back("IntDir");
|
|
SolutionParserUtility::m_ideMacros.push_back("OutDir");
|
|
SolutionParserUtility::m_ideMacros.push_back("DevEnvDir");
|
|
SolutionParserUtility::m_ideMacros.push_back("InputPath");
|
|
SolutionParserUtility::m_ideMacros.push_back("InputName");
|
|
SolutionParserUtility::m_ideMacros.push_back("InputFileName");
|
|
SolutionParserUtility::m_ideMacros.push_back("InputExt");
|
|
SolutionParserUtility::m_ideMacros.push_back("ProjectDir");
|
|
SolutionParserUtility::m_ideMacros.push_back("ProjectPath");
|
|
SolutionParserUtility::m_ideMacros.push_back("ProjectName");
|
|
SolutionParserUtility::m_ideMacros.push_back("ProjectFileName");
|
|
SolutionParserUtility::m_ideMacros.push_back("ProjectExt");
|
|
SolutionParserUtility::m_ideMacros.push_back("SolutionDir");
|
|
SolutionParserUtility::m_ideMacros.push_back("SolutionPath");
|
|
SolutionParserUtility::m_ideMacros.push_back("SolutionName");
|
|
SolutionParserUtility::m_ideMacros.push_back("SolutionExt");
|
|
SolutionParserUtility::m_ideMacros.push_back("TargetDir");
|
|
SolutionParserUtility::m_ideMacros.push_back("TargetPath");
|
|
SolutionParserUtility::m_ideMacros.push_back("TargetName");
|
|
SolutionParserUtility::m_ideMacros.push_back("TargetFileName");
|
|
SolutionParserUtility::m_ideMacros.push_back("VSInstallDir");
|
|
SolutionParserUtility::m_ideMacros.push_back("VCInstallDir");
|
|
SolutionParserUtility::m_ideMacros.push_back("FrameworkDir");
|
|
SolutionParserUtility::m_ideMacros.push_back("FrameworkVersion");
|
|
SolutionParserUtility::m_ideMacros.push_back("FrameworkSDKDir");
|
|
SolutionParserUtility::m_ideMacros.push_back("WebDeployPath");
|
|
SolutionParserUtility::m_ideMacros.push_back("WebDeployRoot");
|
|
SolutionParserUtility::m_ideMacros.push_back("SafeParentName");
|
|
SolutionParserUtility::m_ideMacros.push_back("SafeInputName");
|
|
SolutionParserUtility::m_ideMacros.push_back("SafeRootNamespace");
|
|
SolutionParserUtility::m_ideMacros.push_back("FxCopDir");
|
|
}
|
|
|
|
SolutionParserVisualStudio::~SolutionParserVisualStudio()
|
|
{
|
|
|
|
}
|
|
|
|
std::string SolutionParserVisualStudio::getToolID() const
|
|
{
|
|
return "vs";
|
|
}
|
|
|
|
std::string SolutionParserVisualStudio::getSolutionName()
|
|
{
|
|
std::string result = "";
|
|
|
|
if (m_solutionName.size() > 0)
|
|
{
|
|
size_t pos = m_solutionName.find(".sln");
|
|
if (pos == std::string::npos)
|
|
{
|
|
pos = m_solutionName.find(".vcxproj");
|
|
}
|
|
|
|
if (pos != std::string::npos)
|
|
{
|
|
result = m_solutionName.substr(0, pos);
|
|
}
|
|
else
|
|
{
|
|
result = m_solution;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
std::vector<std::string> SolutionParserVisualStudio::getProjects()
|
|
{
|
|
std::vector<std::string> projectFiles;
|
|
|
|
if (m_solutionName.size() > 0 && m_solutionName.find(".vcxproj") != std::string::npos)
|
|
{
|
|
projectFiles.push_back(m_solutionName);
|
|
return projectFiles;
|
|
}
|
|
|
|
if (m_solution.size() > 0)
|
|
{
|
|
std::vector<std::string> blocks = getProjectBlocks(m_solution);
|
|
|
|
for (unsigned int i = 0; i < blocks.size(); i++)
|
|
{
|
|
projectFiles.push_back(getProjectFilePath(blocks[i]));
|
|
}
|
|
}
|
|
|
|
return projectFiles;
|
|
}
|
|
|
|
std::vector<std::string> SolutionParserVisualStudio::getProjectFiles()
|
|
{
|
|
std::vector<std::string> projectFiles;
|
|
std::vector<std::string> projectFilesNames = getProjects();
|
|
|
|
for (unsigned int i = 0; i < projectFilesNames.size(); i++)
|
|
{
|
|
projectFiles.push_back(loadFile(m_solutionPath + projectFilesNames[i]));
|
|
}
|
|
|
|
//projectFiles.push_back(loadFile(m_solutionPath + "foo.xml"));
|
|
|
|
return projectFiles;
|
|
}
|
|
|
|
std::vector<std::string> SolutionParserVisualStudio::getProjectItems()
|
|
{
|
|
std::vector<std::string> projectItems = findProjectItems();
|
|
|
|
projectItems = SolutionParserUtility::makePathsCanonical(projectItems);
|
|
|
|
return projectItems;
|
|
}
|
|
|
|
std::vector<std::string> SolutionParserVisualStudio::getIncludePaths()
|
|
{
|
|
std::vector<std::string> includePaths = findIncludePaths();
|
|
|
|
includePaths = SolutionParserUtility::makePathsCanonical(includePaths);
|
|
|
|
return includePaths;
|
|
}
|
|
|
|
std::vector<std::string> SolutionParserVisualStudio::getCompileFlags()
|
|
{
|
|
std::vector<std::string> compilerFlags;
|
|
|
|
std::vector<std::string> projectFiles = getProjectFiles();
|
|
|
|
std::vector<std::string> validExtensions;
|
|
validExtensions.push_back(".c");
|
|
validExtensions.push_back(".cpp");
|
|
validExtensions.push_back(".h");
|
|
validExtensions.push_back(".hpp");
|
|
|
|
for (unsigned int i = 0; i < projectFiles.size(); i++)
|
|
{
|
|
TiXmlDocument doc;
|
|
doc.Parse(projectFiles[i].c_str(), 0, TIXML_ENCODING_UTF8);
|
|
|
|
std::string error = doc.ErrorDesc();
|
|
|
|
if (error.length() > 0)
|
|
{
|
|
LOG_ERROR_STREAM(<< "Failed to parse project file " << i << ": " << error);
|
|
continue;
|
|
}
|
|
|
|
std::vector<TiXmlElement*> nodes = SolutionParserUtility::getAllTagsByName(doc.RootElement(), "PreprocessorDefinitions");
|
|
|
|
for (unsigned int j = 0; j < nodes.size(); j++)
|
|
{
|
|
compilerFlags.push_back(std::string(nodes[j]->GetText()));
|
|
}
|
|
}
|
|
|
|
compilerFlags = seperateCompilerFlags(compilerFlags);
|
|
|
|
for (unsigned int i = 0; i < compilerFlags.size(); i++)
|
|
{
|
|
compilerFlags[i] = "-D " + compilerFlags[i];
|
|
}
|
|
|
|
for (unsigned int i = 0; i < m_compatibilityFlags.size(); i++)
|
|
{
|
|
compilerFlags.push_back(m_compatibilityFlags[i]);
|
|
}
|
|
|
|
std::set<std::string> s(compilerFlags.begin(), compilerFlags.end());
|
|
compilerFlags.assign(s.begin(), s.end());
|
|
|
|
return compilerFlags;
|
|
}
|
|
|
|
ProjectSettings SolutionParserVisualStudio::getProjectSettings(const std::string& solutionFilePath)
|
|
{
|
|
LOG_INFO_STREAM(<< "Starting to parse VS solution");
|
|
|
|
LOG_INFO_STREAM(<< "Opening solution file");
|
|
|
|
openSolutionFile(solutionFilePath);
|
|
|
|
SolutionParserUtility::m_ideMacroValues.clear();
|
|
SolutionParserUtility::m_ideMacroValues["SolutionPath"] = solutionFilePath;
|
|
SolutionParserUtility::m_ideMacroValues["SolutionDir"] = m_solutionPath.substr(0, m_solutionPath.size() - 1); // remove trailing slash, would cause problems during path resolving
|
|
SolutionParserUtility::m_ideMacroValues["SolutionName"] = getSolutionName();
|
|
SolutionParserUtility::m_ideMacroValues["SolutionFileName"] = m_solutionName;
|
|
|
|
LOG_INFO_STREAM(<< "Setting meta information");
|
|
|
|
ProjectSettings settings;
|
|
settings.setProjectName(getSolutionName());
|
|
settings.setProjectFileLocation(getSolutionPath());
|
|
settings.setVisualStudioSolutionPath(solutionFilePath);
|
|
|
|
LOG_INFO_STREAM(<< "Parsing project files");
|
|
|
|
LOG_INFO_STREAM(<< "Setting source files");
|
|
|
|
std::vector<std::string> sourceFiles = getProjectItems();
|
|
std::vector<FilePath> sourcePaths;
|
|
for (const std::string& p : sourceFiles)
|
|
{
|
|
sourcePaths.push_back(FilePath(p));
|
|
}
|
|
|
|
LOG_INFO_STREAM(<< "Parsing include files");
|
|
|
|
std::vector<std::string> includePaths = getIncludePaths();
|
|
|
|
std::vector<FilePath> headerPaths;
|
|
for (const std::string& p : includePaths)
|
|
{
|
|
headerPaths.push_back(FilePath(p));
|
|
}
|
|
|
|
LOG_INFO_STREAM(<< "Setting compile flags");
|
|
|
|
std::vector<std::string> compilerFlags = getCompileFlags();
|
|
settings.setCompilerFlags(compilerFlags);
|
|
|
|
settings.setSourcePaths(sourcePaths);
|
|
settings.setHeaderSearchPaths(headerPaths);
|
|
|
|
LOG_INFO_STREAM(<< "Done parsing VS solution");
|
|
|
|
return settings;
|
|
}
|
|
|
|
std::string SolutionParserVisualStudio::getIdeName() const
|
|
{
|
|
return "Visual Studio";
|
|
}
|
|
|
|
std::string SolutionParserVisualStudio::getButtonText() const
|
|
{
|
|
return "from Visual\nStudio Solution";
|
|
}
|
|
|
|
std::string SolutionParserVisualStudio::getDescription() const
|
|
{
|
|
return "Create a new project from an existing Visual Studio Solution file.";
|
|
}
|
|
|
|
std::string SolutionParserVisualStudio::getIconPath() const
|
|
{
|
|
return "icon/project_vs_256_256.png";
|
|
}
|
|
|
|
std::string SolutionParserVisualStudio::getFileExtension() const
|
|
{
|
|
return ".sln";
|
|
}
|
|
|
|
std::vector<std::string> SolutionParserVisualStudio::getProjectItemsNonCanonical()
|
|
{
|
|
return findProjectItems();
|
|
}
|
|
|
|
std::vector<std::string> SolutionParserVisualStudio::getIncludePathsNonCanonical()
|
|
{
|
|
return findIncludePaths();
|
|
}
|
|
|
|
std::vector<std::string> SolutionParserVisualStudio::findProjectItems()
|
|
{
|
|
std::vector<std::string> projectItems;
|
|
|
|
std::vector<std::string> projectFilesNames = getProjects();
|
|
std::vector<std::string> projectFiles = getProjectFiles();
|
|
|
|
std::vector<std::string> relativeProjectPaths;
|
|
|
|
std::vector<std::string> validFileExtensions;
|
|
validFileExtensions.push_back(".c");
|
|
validFileExtensions.push_back(".cpp");
|
|
validFileExtensions.push_back(".h");
|
|
validFileExtensions.push_back(".hpp");
|
|
|
|
for (unsigned int i = 0; i < projectFilesNames.size(); i++)
|
|
{
|
|
size_t pos = projectFilesNames[i].find_last_of("/");
|
|
if (pos == std::string::npos)
|
|
{
|
|
pos = projectFilesNames[i].find_last_of("\\");
|
|
}
|
|
|
|
if (pos != std::string::npos)
|
|
{
|
|
relativeProjectPaths.push_back(projectFilesNames[i].substr(0, pos));
|
|
}
|
|
else
|
|
{
|
|
relativeProjectPaths.push_back("");
|
|
}
|
|
}
|
|
|
|
for (unsigned int i = 0; i < projectFiles.size(); i++)
|
|
{
|
|
TiXmlDocument doc;
|
|
doc.Parse(projectFiles[i].c_str(), 0, TIXML_ENCODING_UTF8);
|
|
|
|
std::string error = doc.ErrorDesc();
|
|
|
|
if (error.length() > 0)
|
|
{
|
|
LOG_ERROR_STREAM(<< "Failed to parse project file " << i << ": " << error);
|
|
continue;
|
|
}
|
|
|
|
TiXmlElement* root = SolutionParserUtility::getFirstTagByNameWithAttribute(doc.RootElement(), "ClCompile", "Include");
|
|
TiXmlElement* headerRoot = SolutionParserUtility::getFirstTagByNameWithAttribute(doc.RootElement(), "ClInclude", "Include");
|
|
if (root != NULL)
|
|
{
|
|
// std::string text(root->GetText());
|
|
std::string tag = root->Value();
|
|
std::string text = "";
|
|
if (root->Attribute("Include") != NULL)
|
|
{
|
|
text = root->Attribute("Include");
|
|
}
|
|
|
|
if (text.find(".cpp") == std::string::npos && text.find(".c") == std::string::npos)
|
|
{
|
|
root = NULL;
|
|
}
|
|
else
|
|
{
|
|
root = root->Parent()->ToElement();
|
|
}
|
|
}
|
|
|
|
if (headerRoot != NULL)
|
|
{
|
|
std::string tag = headerRoot->Value();
|
|
std::string text = "";
|
|
if (headerRoot->Attribute("Include") != NULL)
|
|
{
|
|
text = headerRoot->Attribute("Include");
|
|
}
|
|
|
|
if (text.find(".h") == std::string::npos && text.find(".hpp") == std::string::npos)
|
|
{
|
|
headerRoot = NULL;
|
|
}
|
|
else
|
|
{
|
|
headerRoot = headerRoot->Parent()->ToElement();
|
|
}
|
|
}
|
|
|
|
/*if (root == NULL)
|
|
{
|
|
TiXmlElement* root = getFirstTagByNameWithAttribute(doc.RootElement(), "ClInclude", "Include");
|
|
if (root != NULL)
|
|
{
|
|
root = root->Parent()->ToElement();
|
|
}
|
|
else
|
|
{
|
|
root = NULL;
|
|
}
|
|
}*/
|
|
|
|
|
|
|
|
if (root != NULL)
|
|
{
|
|
for (TiXmlElement* child = root->FirstChildElement(); child != NULL; child = child->NextSiblingElement())
|
|
{
|
|
std::string filePath = child->Attribute("Include");
|
|
|
|
if (boost::filesystem::exists(filePath) && SolutionParserUtility::checkValidFileExtension(filePath, validFileExtensions))
|
|
{
|
|
projectItems.push_back(filePath);
|
|
continue;
|
|
}
|
|
|
|
if (relativeProjectPaths[i].size() > 0)
|
|
{
|
|
filePath = relativeProjectPaths[i] + "/" + filePath;
|
|
}
|
|
|
|
if (SolutionParserUtility::checkValidFileExtension(filePath, validFileExtensions))
|
|
{
|
|
projectItems.push_back(filePath);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (headerRoot != NULL)
|
|
{
|
|
for (TiXmlElement* child = headerRoot->FirstChildElement(); child != NULL; child = child->NextSiblingElement())
|
|
{
|
|
std::string filePath = child->Attribute("Include");
|
|
|
|
if (boost::filesystem::exists(filePath) && SolutionParserUtility::checkValidFileExtension(filePath, validFileExtensions))
|
|
{
|
|
projectItems.push_back(filePath);
|
|
continue;
|
|
}
|
|
|
|
if (relativeProjectPaths[i].size() > 0)
|
|
{
|
|
filePath = relativeProjectPaths[i] + "/" + filePath;
|
|
}
|
|
|
|
if (SolutionParserUtility::checkValidFileExtension(filePath, validFileExtensions))
|
|
{
|
|
projectItems.push_back(filePath);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
std::set<std::string> s(projectItems.begin(), projectItems.end());
|
|
projectItems.assign(s.begin(), s.end());
|
|
|
|
LOG_INFO_STREAM(<< "Found " << projectItems.size() << " code files");
|
|
|
|
projectItems = SolutionParserUtility::resolveEnvironmentVariables(projectItems);
|
|
projectItems = makePathsAbsolute(projectItems);
|
|
|
|
return projectItems;
|
|
}
|
|
|
|
std::vector<std::string> SolutionParserVisualStudio::findIncludePaths()
|
|
{
|
|
std::vector<std::string> includePaths;
|
|
|
|
std::vector<std::string> projectFiles = getProjectFiles();
|
|
|
|
std::vector<std::string> validExtensions;
|
|
validExtensions.push_back(".c");
|
|
validExtensions.push_back(".cpp");
|
|
validExtensions.push_back(".h");
|
|
validExtensions.push_back(".hpp");
|
|
|
|
for (unsigned int i = 0; i < projectFiles.size(); i++)
|
|
{
|
|
TiXmlDocument doc;
|
|
doc.Parse(projectFiles[i].c_str(), 0, TIXML_ENCODING_UTF8);
|
|
|
|
std::string error = doc.ErrorDesc();
|
|
|
|
if (error.length() > 0)
|
|
{
|
|
LOG_ERROR_STREAM(<< "Failed to parse project file " << i << ": " << error);
|
|
continue;
|
|
}
|
|
|
|
std::vector<TiXmlElement*> nodes = SolutionParserUtility::getAllTagsByName(doc.RootElement(), "AdditionalIncludeDirectories");
|
|
|
|
for (unsigned int j = 0; j < nodes.size(); j++)
|
|
{
|
|
std::string path = nodes[j]->GetText();
|
|
|
|
includePaths.push_back(path);
|
|
}
|
|
}
|
|
|
|
includePaths = seperateIncludePaths(includePaths);
|
|
|
|
std::set<std::string> s(includePaths.begin(), includePaths.end());
|
|
includePaths.assign(s.begin(), s.end());
|
|
|
|
LOG_INFO_STREAM(<< "Found " << includePaths.size() << " additional include paths");
|
|
|
|
includePaths = SolutionParserUtility::resolveEnvironmentVariables(includePaths);
|
|
includePaths = makePathsAbsolute(includePaths);
|
|
|
|
return includePaths;
|
|
}
|
|
|
|
std::vector<std::string> SolutionParserVisualStudio::getProjectBlocks(const std::string& solution) const
|
|
{
|
|
std::vector<std::string> blocks;
|
|
|
|
std::string subSolution = solution;
|
|
|
|
std::string solutionOpenTag = "\nProject";
|
|
std::string solutionCloseTag = "\nEndProject";
|
|
|
|
size_t blockStart = subSolution.find(solutionOpenTag, 0);
|
|
size_t blockEnd = subSolution.find(solutionCloseTag, 0);
|
|
|
|
while (blockStart != std::string::npos && blockEnd != std::string::npos)
|
|
{
|
|
std::string block = subSolution.substr(blockStart, blockEnd - blockStart + solutionCloseTag.size());
|
|
|
|
if (subSolution.size() > blockEnd + solutionCloseTag.size())
|
|
{
|
|
subSolution = subSolution.substr(blockEnd + solutionCloseTag.size());
|
|
}
|
|
else
|
|
{
|
|
subSolution = "";
|
|
}
|
|
|
|
blockStart = subSolution.find(solutionOpenTag);
|
|
blockEnd = subSolution.find(solutionCloseTag);
|
|
|
|
blocks.push_back(block);
|
|
}
|
|
|
|
return blocks;
|
|
}
|
|
|
|
std::string SolutionParserVisualStudio::getProjectFilePath(const std::string& projectBlock) const
|
|
{
|
|
std::string projectFilePath;
|
|
|
|
std::string fileEnding = "vcxproj";
|
|
|
|
size_t pos = projectBlock.find(fileEnding);
|
|
|
|
if (pos != std::string::npos)
|
|
{
|
|
std::string searchArea = projectBlock.substr(0, pos + fileEnding.size());
|
|
pos = searchArea.find_last_of("\"");
|
|
projectFilePath = searchArea.substr(pos + 1);
|
|
}
|
|
|
|
return projectFilePath;
|
|
}
|
|
|
|
std::vector<std::string> SolutionParserVisualStudio::seperateIncludePaths(const std::vector<std::string>& includePaths) const
|
|
{
|
|
std::vector<std::string> seperatedPaths;
|
|
|
|
for (unsigned int i = 0; i < includePaths.size(); i++)
|
|
{
|
|
std::vector<std::string> paths = seperateIncludePaths(includePaths[i]);
|
|
for (unsigned int j = 0; j < paths.size(); j++)
|
|
{
|
|
seperatedPaths.push_back(paths[j]);
|
|
}
|
|
}
|
|
|
|
return seperatedPaths;
|
|
}
|
|
|
|
std::vector<std::string> SolutionParserVisualStudio::seperateIncludePaths(const std::string& includePaths) const
|
|
{
|
|
std::string paths = includePaths;
|
|
std::string seperator = ";";
|
|
|
|
std::vector<std::string> seperatedPaths;
|
|
|
|
size_t pos = includePaths.find(seperator);
|
|
|
|
while (pos != std::string::npos)
|
|
{
|
|
std::string path = paths.substr(0, pos);
|
|
paths = paths.substr(pos + 1);
|
|
|
|
seperatedPaths.push_back(path);
|
|
|
|
pos = paths.find(seperator);
|
|
}
|
|
|
|
if (paths.size() > 0)
|
|
{
|
|
seperatedPaths.push_back(paths);
|
|
}
|
|
|
|
return seperatedPaths;
|
|
}
|
|
|
|
std::vector<std::string> SolutionParserVisualStudio::seperateCompilerFlags(const std::vector<std::string>& compilerFlags) const
|
|
{
|
|
std::vector<std::string> seperatedFlags;
|
|
|
|
for (unsigned int i = 0; i < compilerFlags.size(); i++)
|
|
{
|
|
std::vector<std::string> paths = seperateCompilerFlags(compilerFlags[i]);
|
|
for (unsigned int j = 0; j < paths.size(); j++)
|
|
{
|
|
seperatedFlags.push_back(paths[j]);
|
|
}
|
|
}
|
|
|
|
return seperatedFlags;
|
|
}
|
|
|
|
std::vector<std::string> SolutionParserVisualStudio::seperateCompilerFlags(const std::string& compilerFlags) const
|
|
{
|
|
std::string flags = compilerFlags;
|
|
std::string seperator = ";";
|
|
|
|
std::vector<std::string> seperatedFlags;
|
|
|
|
size_t pos = flags.find(seperator);
|
|
|
|
while (pos != std::string::npos)
|
|
{
|
|
std::string flag = flags.substr(0, pos);
|
|
flags = flags.substr(pos + 1);
|
|
|
|
seperatedFlags.push_back(flag);
|
|
|
|
pos = flags.find(seperator);
|
|
}
|
|
|
|
return seperatedFlags;
|
|
}
|