ynkmr/Sourcetrail
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

ui: autodetect java on windows

Browse Source 
* implemented a more generic approach to detecting filepaths
* reimplemented standard header detection using this approach
* added auto detection of JVM dynamic library on windows
* fixed java tests that were broken when updating the java_indexer project before this commit.
This commit is contained in:
malte_langkabel
2016-08-24 15:21:04 +02:00
parent 01f740276b
commit 8dfc1ea9d9
30 changed files with 508 additions and 370 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/lib/data/parser/java/JavaEnvironmentFactory.cpp
+2 -2
View File
@@ -37,7 +37,7 @@ void JavaEnvironmentFactory::createInstance(std::string classPath)
{
std::string oldPathContent = getenv("path");
std::string javapath = ApplicationSettings::getInstance()->getJavaPath() + "/client/";
std::string javapath = ApplicationSettings::getInstance()->getJavaPath() + "/";
putenv(("path=" + oldPathContent + ";" + javapath).c_str()); // path env is only modified in the scope of this process.
javaFound = FileSystem::exists(javapath + "jvm.dll");
@@ -88,7 +88,7 @@ void JavaEnvironmentFactory::createInstance(std::string classPath)
JavaVMOption* options = new JavaVMOption[3]; // JVM invocation options
std::string classPathOption = "-Djava.class.path=" + classPath;
options[0].optionString = const_cast<char*>(classPathOption.c_str());
options[1].optionString = const_cast<char*>("-Xms1m");
options[1].optionString = const_cast<char*>("-Xms64m");
std::string maximumMemoryOprionString = "-Xmx" + std::to_string(ApplicationSettings::getInstance()->getJavaMaximumMemory()) + "m";
options[2].optionString = const_cast<char*>(maximumMemoryOprionString.c_str());
vm_args.version = JNI_VERSION_1_6;
src/lib_gui/CMakeLists.txt
+19 -9
View File
@@ -164,15 +164,25 @@ add_files(
qt/QtApplication.h
qt/QtCoreApplication.cpp
qt/QtCoreApplication.h
utility/headerSearch/CompilerDetector.cpp
utility/headerSearch/CompilerDetector.h
utility/headerSearch/DetectorBase.cpp
utility/headerSearch/DetectorBase.h
utility/headerSearch/StandardHeaderDetection.cpp
utility/headerSearch/StandardHeaderDetection.h
utility/headerSearch/VisualStudioDetector.cpp
utility/headerSearch/VisualStudioDetector.h
utility/path_detector/cxx_header/CxxFrameworkPathDetector.cpp
utility/path_detector/cxx_header/CxxFrameworkPathDetector.h
utility/path_detector/cxx_header/CxxHeaderPathDetector.cpp
utility/path_detector/cxx_header/CxxHeaderPathDetector.h
utility/path_detector/cxx_header/CxxVsHeaderPathDetector.cpp
utility/path_detector/cxx_header/CxxVsHeaderPathDetector.h
utility/path_detector/cxx_header/utilityCxxHeaderDetection.cpp
utility/path_detector/cxx_header/utilityCxxHeaderDetection.h
utility/path_detector/java_runtime/JavaPathDetector.cpp
utility/path_detector/java_runtime/JavaPathDetector.h
utility/path_detector/java_runtime/JavaPathDetectorWindows.cpp
utility/path_detector/java_runtime/JavaPathDetectorWindows.h
utility/path_detector/CombinedPathDetector.cpp
utility/path_detector/CombinedPathDetector.h
utility/path_detector/PathDetector.cpp
utility/path_detector/PathDetector.h
utility/utilityApp.cpp
utility/utilityApp.h
src/lib_gui/qt/window/project_wizzard/QtProjectWizzardContentPaths.cpp
+24 -22
View File
@@ -10,7 +10,9 @@
#include "settings/JavaProjectSettings.h"
#include "utility/file/FileManager.h"
#include "utility/file/FileSystem.h"
#include "utility/headerSearch/StandardHeaderDetection.h"
#include "utility/path_detector/cxx_header/CxxFrameworkPathDetector.h"
#include "utility/path_detector/cxx_header/CxxHeaderPathDetector.h"
#include "utility/path_detector/cxx_header/CxxVsHeaderPathDetector.h"
#include "utility/utility.h"
QtProjectWizzardContentPaths::QtProjectWizzardContentPaths(std::shared_ptr<ProjectSettings> settings, QtProjectWizzardWindow* window)
@@ -45,9 +47,9 @@ void QtProjectWizzardContentPaths::populateWindow(QGridLayout* layout, int& row)
addFilesButton(m_showFilesString, layout, row);
}
if (m_detectionString.size() > 0)
if (m_pathDetector)
{
addDetection(m_detectionString, layout, row);
addDetection(layout, row);
}
row++;
@@ -76,9 +78,9 @@ void QtProjectWizzardContentPaths::populateForm(QGridLayout* layout, int& row)
row++;
}
if (m_detectionString.size() > 0)
if (m_pathDetector)
{
addDetection(m_detectionString, layout, row);
addDetection(layout, row);
row++;
}
}
@@ -140,10 +142,9 @@ void QtProjectWizzardContentPaths::setHelpString(const QString& help)
m_helpString = help;
}
void QtProjectWizzardContentPaths::addDetection(QString name, QGridLayout* layout, int row)
void QtProjectWizzardContentPaths::addDetection(QGridLayout* layout, int row)
{
StandardHeaderDetection detection;
std::vector<std::string> detectorNames = detection.getWorkingDetectorNames();
std::vector<std::string> detectorNames = m_pathDetector->getWorkingDetectorNames();
if (!detectorNames.size())
{
return;
@@ -175,18 +176,7 @@ void QtProjectWizzardContentPaths::addDetection(QString name, QGridLayout* layou
void QtProjectWizzardContentPaths::detectionClicked()
{
StandardHeaderDetection detection;
std::vector<FilePath> paths;
if (m_detectionString == "headers")
{
paths = detection.getStandardHeaderPaths(m_detectorBox->currentText().toStdString());
}
else if (m_detectionString == "frameworks")
{
paths = detection.getStandardFrameworkPaths(m_detectorBox->currentText().toStdString());
}
std::vector<FilePath> paths = m_pathDetector->getPaths(m_detectorBox->currentText().toStdString());
std::vector<FilePath> oldPaths = m_list->getList();
m_list->setList(utility::unique(utility::concat(oldPaths, paths)));
}
@@ -382,7 +372,17 @@ QtProjectWizzardContentPathsHeaderSearchGlobal::QtProjectWizzardContentPathsHead
"Include Paths defined here will be used for all projects."
);
m_detectionString = "headers";
m_pathDetector = std::make_shared<CombinedPathDetector>();
m_pathDetector->addDetector(std::make_shared<CxxHeaderPathDetector>("gcc"));
m_pathDetector->addDetector(std::make_shared<CxxHeaderPathDetector>("clang"));
m_pathDetector->addDetector(std::make_shared<CxxVsHeaderPathDetector>(9, false));
m_pathDetector->addDetector(std::make_shared<CxxVsHeaderPathDetector>(9, true));
m_pathDetector->addDetector(std::make_shared<CxxVsHeaderPathDetector>(11, false));
m_pathDetector->addDetector(std::make_shared<CxxVsHeaderPathDetector>(11, true));
m_pathDetector->addDetector(std::make_shared<CxxVsHeaderPathDetector>(12, false));
m_pathDetector->addDetector(std::make_shared<CxxVsHeaderPathDetector>(12, true));
m_pathDetector->addDetector(std::make_shared<CxxVsHeaderPathDetector>(14, false));
m_pathDetector->addDetector(std::make_shared<CxxVsHeaderPathDetector>(14, true));
}
void QtProjectWizzardContentPathsHeaderSearchGlobal::load()
@@ -448,7 +448,9 @@ QtProjectWizzardContentPathsFrameworkSearchGlobal::QtProjectWizzardContentPathsF
"Framework Search Paths defined here will be used for all projects."
);
m_detectionString = "frameworks";
m_pathDetector = std::make_shared<CombinedPathDetector>();
m_pathDetector->addDetector(std::make_shared<CxxFrameworkPathDetector>("gcc"));
m_pathDetector->addDetector(std::make_shared<CxxFrameworkPathDetector>("clang"));
}
void QtProjectWizzardContentPathsFrameworkSearchGlobal::load()
src/lib_gui/qt/window/project_wizzard/QtProjectWizzardContentPaths.h
+3 -2
View File
@@ -5,6 +5,7 @@
#include <QPushButton>
#include "qt/window/project_wizzard/QtProjectWizzardContent.h"
#include "utility/path_detector/CombinedPathDetector.h"
class QtDirectoryListBox;
@@ -33,12 +34,12 @@ protected:
void setDescriptionString(const QString& description);
void setHelpString(const QString& help);
void addDetection(QString name, QGridLayout* layout, int row);
void addDetection(QGridLayout* layout, int row);
QtDirectoryListBox* m_list;
QString m_showFilesString;
QString m_detectionString;
std::shared_ptr<CombinedPathDetector> m_pathDetector;
private slots:
void detectionClicked();
src/lib_gui/qt/window/project_wizzard/QtProjectWizzardContentPreferences.cpp
+54 -3
View File
@@ -1,8 +1,9 @@
#include "qt/window/project_wizzard/QtProjectWizzardContentPreferences.h"
#include "settings/ApplicationSettings.h"
#include "utility/messaging/type/MessageSwitchColorScheme.h"
#include "utility/file/FileSystem.h"
#include "utility/messaging/type/MessageSwitchColorScheme.h"
#include "utility/path_detector/java_runtime/JavaPathDetectorWindows.h"
#include "utility/ResourcePaths.h"
QtProjectWizzardContentPreferences::QtProjectWizzardContentPreferences(
@@ -143,17 +144,25 @@ void QtProjectWizzardContentPreferences::populateForm(QGridLayout* layout, int&
// java path
m_javaPath = new QtLocationPicker(this);
m_javaPath->setPickDirectory(true);
m_javaPath->setPlaceholderText("<jdk_root>");
m_javaPath->setPlaceholderText("<jre_8_root>/bin/client");
layout->addWidget(createFormLabel("Java Path"), row, QtProjectWizzardWindow::FRONT_COL, Qt::AlignRight);
layout->addWidget(m_javaPath, row, QtProjectWizzardWindow::BACK_COL);
addHelpButton(
"Location of your java installation so that dynamic libraries of JVM can be found."
"Location of the folder that contains the dynamic library for your jre virtual machine."
, layout, row
);
row++;
if (QSysInfo::windowsVersion() != QSysInfo::WV_None)
{
m_javaPathDetector = std::make_shared<CombinedPathDetector>();
m_javaPathDetector->addDetector(std::make_shared<JavaPathDetectorWindows>("1.8"));
addJavaPathDetection(layout, row);
row++;
}
layout->setRowMinimumHeight(row++, 20);
// C/C++
@@ -228,3 +237,45 @@ void QtProjectWizzardContentPreferences::colorSchemeChanged(int index)
{
MessageSwitchColorScheme(m_colorSchemePaths[index]).dispatch();
}
void QtProjectWizzardContentPreferences::javaPathDetectionClicked()
{
std::vector<FilePath> paths = m_javaPathDetector->getPaths(m_javaPathDetectorBox->currentText().toStdString());
if (!paths.empty())
{
m_javaPath->setText(paths.front().str().c_str());
}
}
void QtProjectWizzardContentPreferences::addJavaPathDetection(QGridLayout* layout, int row)
{
std::vector<std::string> detectorNames = m_javaPathDetector->getWorkingDetectorNames();
if (!detectorNames.size())
{
return;
}
QLabel* label = new QLabel("Auto detection from:");
m_javaPathDetectorBox = new QComboBox();
for (const std::string& detectorName: detectorNames)
{
m_javaPathDetectorBox->addItem(detectorName.c_str());
}
QPushButton* button = new QPushButton("detect");
button->setObjectName("windowButton");
connect(button, SIGNAL(clicked()), this, SLOT(javaPathDetectionClicked()));
QHBoxLayout* hlayout = new QHBoxLayout();
hlayout->addWidget(label);
hlayout->addWidget(m_javaPathDetectorBox);
hlayout->addWidget(button);
QWidget* detectionWidget = new QWidget();
detectionWidget->setLayout(hlayout);
layout->addWidget(detectionWidget, row, QtProjectWizzardWindow::BACK_COL, Qt::AlignLeft | Qt::AlignTop);
}
src/lib_gui/qt/window/project_wizzard/QtProjectWizzardContentPreferences.h
+6
View File
@@ -7,6 +7,7 @@
#include "qt/element/QtLocationPicker.h"
#include "qt/window/project_wizzard/QtProjectWizzardContent.h"
#include "utility/path_detector/CombinedPathDetector.h"
class QtProjectWizzardContentPreferences
: public QtProjectWizzardContent
@@ -27,8 +28,11 @@ public:
private slots:
void colorSchemeChanged(int index);
void javaPathDetectionClicked();
private:
void addJavaPathDetection(QGridLayout* layout, int row);
QLineEdit* m_fontFace;
QComboBox* m_fontSize;
QComboBox* m_tabWidth;
@@ -41,6 +45,8 @@ private:
QComboBox* m_threads;
QCheckBox* m_fatalErrors;
std::shared_ptr<CombinedPathDetector> m_javaPathDetector;
QComboBox* m_javaPathDetectorBox;
QtLocationPicker* m_javaPath;
};
src/lib_gui/utility/headerSearch/CompilerDetector.cpp
-62
View File
@@ -1,62 +0,0 @@
#include "utility/headerSearch/CompilerDetector.h"
#include "utility/utilityApp.h"
#include "utility/utilityString.h"
CompilerDetector::CompilerDetector(const std::string& name)
: DetectorBase(name)
{
}
CompilerDetector::~CompilerDetector()
{
}
std::vector<FilePath> CompilerDetector::getStandardHeaderPaths()
{
std::vector<std::string> paths = getHeaderPaths();
std::vector<FilePath> headerPaths;
for (const std::string& path : paths)
{
if (!utility::isPostfix(" (framework directory)", path))
{
headerPaths.push_back(FilePath(path).canonical());
}
}
return headerPaths;
}
std::vector<FilePath> CompilerDetector::getStandardFrameworkPaths()
{
std::vector<std::string> paths = getHeaderPaths();
std::vector<FilePath> frameworkPaths;
for (const std::string& path : paths)
{
if (utility::isPostfix(" (framework directory)", path))
{
frameworkPaths.push_back(FilePath(utility::replace(path, " (framework directory)", "")).canonical());
}
}
return frameworkPaths;
}
std::vector<std::string> CompilerDetector::getHeaderPaths()
{
std::string command = m_name + " -x c++ -v -E /dev/null";
std::string clangOutput = utility::executeProcess(command.c_str());
std::string standardHeaders =
utility::substrBetween(clangOutput, "#include <...> search starts here:\n","\nEnd of search list");
std::vector<std::string> paths;
if (!standardHeaders.empty())
{
for (std::string s : utility::splitToVector(standardHeaders, '\n'))
{
paths.push_back(utility::trim(s));
}
}
return paths;
}
src/lib_gui/utility/headerSearch/CompilerDetector.h
-21
View File
@@ -1,21 +0,0 @@
#ifndef COMPILER_DETECTOR_H
#define COMPILER_DETECTOR_H
#include "utility/headerSearch/DetectorBase.h"
class CompilerDetector
: public DetectorBase
{
public:
CompilerDetector(const std::string& name);
virtual ~CompilerDetector();
virtual std::vector<FilePath> getStandardHeaderPaths();
virtual std::vector<FilePath> getStandardFrameworkPaths();
private:
std::vector<std::string> getHeaderPaths();
};
#endif // COMPILER_DETECTOR_H
src/lib_gui/utility/headerSearch/DetectorBase.cpp
-20
View File
@@ -1,20 +0,0 @@
#include "utility/headerSearch/DetectorBase.h"
DetectorBase::DetectorBase(const std::string name)
: m_name(name)
{
}
DetectorBase::~DetectorBase()
{
}
std::string DetectorBase::getName() const
{
return m_name;
}
bool DetectorBase::isWorking()
{
return !getStandardHeaderPaths().empty();
}
src/lib_gui/utility/headerSearch/DetectorBase.h
-24
View File
@@ -1,24 +0,0 @@
#ifndef DETECTOR_BASE_H
#define DETECTOR_BASE_H
#include <vector>
#include "utility/file/FilePath.h"
class DetectorBase
{
public:
DetectorBase(const std::string name);
virtual ~DetectorBase();
std::string getName() const;
bool isWorking();
virtual std::vector<FilePath> getStandardHeaderPaths() = 0;
virtual std::vector<FilePath> getStandardFrameworkPaths() = 0;
protected:
std::string m_name;
};
#endif // DETECTOR_BASE_H
src/lib_gui/utility/headerSearch/StandardHeaderDetection.cpp
-102
View File
@@ -1,102 +0,0 @@
#include "utility/headerSearch/StandardHeaderDetection.h"
#include <cstdlib>
#include <iostream>
#include <utility>
#include "utility/headerSearch/CompilerDetector.h"
#include "utility/headerSearch/VisualStudioDetector.h"
#include "utility/logging/logging.h"
StandardHeaderDetection::DetectorMap StandardHeaderDetection::s_availableDetectors;
StandardHeaderDetection::DetectorMap StandardHeaderDetection::s_workingDetectors;
StandardHeaderDetection::StandardHeaderDetection()
{
if (!s_availableDetectors.size())
{
addDetector(std::make_shared<CompilerDetector>("gcc"));
addDetector(std::make_shared<CompilerDetector>("clang"));
addDetector(std::make_shared<VisualStudioDetector>("Visual Studio 2010", 9, false));
addDetector(std::make_shared<VisualStudioDetector>("Visual Studio 2010 Express", 9, true));
addDetector(std::make_shared<VisualStudioDetector>("Visual Studio 2012", 11, false));
addDetector(std::make_shared<VisualStudioDetector>("Visual Studio 2012 Express", 11, true));
addDetector(std::make_shared<VisualStudioDetector>("Visual Studio 2013", 12, false));
addDetector(std::make_shared<VisualStudioDetector>("Visual Studio 2013 Express", 12, true));
addDetector(std::make_shared<VisualStudioDetector>("Visual Studio 2015", 14, false));
addDetector(std::make_shared<VisualStudioDetector>("Visual Studio 2015 Express", 14, true));
detectHeaders();
}
}
StandardHeaderDetection::~StandardHeaderDetection()
{
}
void StandardHeaderDetection::addDetector(std::shared_ptr<DetectorBase> detector)
{
s_availableDetectors.emplace(detector->getName(), detector);
}
void StandardHeaderDetection::detectHeaders()
{
for (DetectorPair detector: s_availableDetectors)
{
if (detector.second->isWorking())
{
s_workingDetectors.insert(detector);
}
}
}
std::vector<std::string> StandardHeaderDetection::getWorkingDetectorNames()
{
std::vector<std::string> detectorNames;
for (DetectorPair detector: s_workingDetectors)
{
detectorNames.push_back(detector.first);
}
return detectorNames;
}
std::vector<FilePath> StandardHeaderDetection::getStandardHeaderPaths(std::string detectorName)
{
DetectorMap::const_iterator it = s_workingDetectors.find(detectorName);
if (it != s_workingDetectors.end())
{
return it->second->getStandardHeaderPaths();
}
return std::vector<FilePath>();
}
std::vector<FilePath> StandardHeaderDetection::getStandardFrameworkPaths(std::string detectorName)
{
DetectorMap::const_iterator it = s_workingDetectors.find(detectorName);
if (it != s_workingDetectors.end())
{
return it->second->getStandardFrameworkPaths();
}
return std::vector<FilePath>();
}
void StandardHeaderDetection::logAvailableDetectors()
{
LOG_INFO("Available Header Detectors:");
for (DetectorPair detector: s_availableDetectors)
{
LOG_INFO("Detector: " + detector.first);
}
}
void StandardHeaderDetection::logWorkingDetectors()
{
LOG_INFO("Working Header Detectors:");
for (std::string detectorName: getWorkingDetectorNames())
{
LOG_INFO("Detector: " + detectorName);
}
}
src/lib_gui/utility/headerSearch/StandardHeaderDetection.h
-42
View File
@@ -1,42 +0,0 @@
#ifndef STANDARD_HEADER_DETECTION_H
#define STANDARD_HEADER_DETECTION_H
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "utility/headerSearch/DetectorBase.h"
class FilePath;
class StandardHeaderDetection
{
public:
StandardHeaderDetection();
~StandardHeaderDetection();
void addDetector(std::shared_ptr<DetectorBase> detector);
/// Checks all availabe detectors and saves found Compilers
void detectHeaders();
std::vector<std::string> getWorkingDetectorNames();
/// Returns the headerpaths from a found compiler
std::vector<FilePath> getStandardHeaderPaths(std::string detectorName);
std::vector<FilePath> getStandardFrameworkPaths(std::string detectorName);
/// Debugging Output
void logAvailableDetectors();
void logWorkingDetectors();
private:
typedef std::map<std::string, std::shared_ptr<DetectorBase>> DetectorMap;
typedef std::pair<std::string, std::shared_ptr<DetectorBase>> DetectorPair;
static DetectorMap s_availableDetectors;
static DetectorMap s_workingDetectors;
};
#endif // STANDARD_HEADER_DETECTION_H
src/lib_gui/utility/headerSearch/VisualStudioDetector.h
-27
View File
@@ -1,27 +0,0 @@
#ifndef VISUAL_STUDIO_DETECTOR_H
#define VISUAL_STUDIO_DETECTOR_H
#include <vector>
#include "utility/headerSearch/DetectorBase.h"
class FilePath;
class VisualStudioDetector: public DetectorBase
{
public:
VisualStudioDetector(const std::string name, int version, bool isExpress);
virtual ~VisualStudioDetector();
virtual std::vector<FilePath> getStandardHeaderPaths();
virtual std::vector<FilePath> getStandardFrameworkPaths();
private:
FilePath getVsInstallPathUsingRegistry();
FilePath getWindowsSdkPathUsingRegistry(const std::string& version);
int m_version;
bool m_isExpress;
};
#endif // VISUAL_STUDIO_DETECTOR_H
src/lib_gui/utility/path_detector/CombinedPathDetector.cpp
+54
View File
@@ -0,0 +1,54 @@
#include "utility/path_detector/CombinedPathDetector.h"
CombinedPathDetector::CombinedPathDetector()
: PathDetector("combined")
{
}
CombinedPathDetector::~CombinedPathDetector()
{
}
void CombinedPathDetector::addDetector(std::shared_ptr<PathDetector> detector)
{
m_detectors[detector->getName()] = detector;
}
std::vector<std::string> CombinedPathDetector::getWorkingDetectorNames()
{
std::vector<std::string> names;
for (DetectorPair detectorEntry: m_detectors)
{
if (detectorEntry.second->isWorking())
{
names.push_back(detectorEntry.first);
}
}
return names;
}
std::vector<FilePath> CombinedPathDetector::getPaths() const
{
for (DetectorPair detectorEntry: m_detectors)
{
std::vector<FilePath> detectedPaths = detectorEntry.second->getPaths();
if (!detectedPaths.empty())
{
return detectedPaths;
}
}
return std::vector<FilePath>();
}
std::vector<FilePath> CombinedPathDetector::getPaths(std::string detectorName) const
{
std::vector<FilePath> paths;
DetectorMap::const_iterator it = m_detectors.find(detectorName);
if (it != m_detectors.end())
{
paths = it->second->getPaths();
}
return paths;
}
src/lib_gui/utility/path_detector/CombinedPathDetector.h
+31
View File
@@ -0,0 +1,31 @@
#ifndef COMBINED_PATH_DETECTOR_H
#define COMBINED_PATH_DETECTOR_H
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "utility/path_detector/PathDetector.h"
class CombinedPathDetector: public PathDetector
{
public:
CombinedPathDetector();
virtual ~CombinedPathDetector();
void addDetector(std::shared_ptr<PathDetector> detector);
std::vector<std::string> getWorkingDetectorNames();
virtual std::vector<FilePath> getPaths() const;
std::vector<FilePath> getPaths(std::string detectorName) const;
private:
typedef std::map<std::string, std::shared_ptr<PathDetector>> DetectorMap;
typedef std::pair<std::string, std::shared_ptr<PathDetector>> DetectorPair;
DetectorMap m_detectors;
};
#endif // COMBINED_PATH_DETECTOR_H
src/lib_gui/utility/path_detector/PathDetector.cpp
+20
View File
@@ -0,0 +1,20 @@
#include "utility/path_detector/PathDetector.h"
PathDetector::PathDetector(const std::string& name)
: m_name(name)
{
}
PathDetector::~PathDetector()
{
}
std::string PathDetector::getName() const
{
return m_name;
}
bool PathDetector::isWorking() const
{
return (!getPaths().empty());
}
src/lib_gui/utility/path_detector/PathDetector.h
+23
View File
@@ -0,0 +1,23 @@
#ifndef PATH_DETECTOR_BASE_H
#define PATH_DETECTOR_BASE_H
#include <string>
#include <vector>
#include "utility/file/FilePath.h"
class PathDetector
{
public:
PathDetector(const std::string& name);
virtual ~PathDetector();
std::string getName() const;
bool isWorking() const;
virtual std::vector<FilePath> getPaths() const = 0;
protected:
const std::string m_name;
};
#endif // PATH_DETECTOR_BASE_H
src/lib_gui/utility/path_detector/cxx_header/CxxFrameworkPathDetector.cpp
+29
View File
@@ -0,0 +1,29 @@
#include "utility/path_detector/cxx_header/CxxFrameworkPathDetector.h"
#include "utility/path_detector/cxx_header/utilityCxxHeaderDetection.h"
#include "utility/utilityApp.h"
#include "utility/utilityString.h"
CxxFrameworkPathDetector::CxxFrameworkPathDetector(const std::string& compilerName)
: PathDetector(compilerName)
, m_compilerName(compilerName)
{
}
CxxFrameworkPathDetector::~CxxFrameworkPathDetector()
{
}
std::vector<FilePath> CxxFrameworkPathDetector::getPaths() const
{
std::vector<std::string> paths = utility::getCxxHeaderPaths(m_compilerName);
std::vector<FilePath> frameworkPaths;
for (const std::string& path : paths)
{
if (utility::isPostfix(" (framework directory)", path))
{
frameworkPaths.push_back(FilePath(utility::replace(path, " (framework directory)", "")).canonical());
}
}
return frameworkPaths;
}
src/lib_gui/utility/path_detector/cxx_header/CxxFrameworkPathDetector.h
+18
View File
@@ -0,0 +1,18 @@
#ifndef CXX_FRAMEWORK_PATH_DETECTOR_H
#define CXX_FRAMEWORK_PATH_DETECTOR_H
#include "utility/path_detector/PathDetector.h"
class CxxFrameworkPathDetector: public PathDetector
{
public:
CxxFrameworkPathDetector(const std::string& compilerName);
virtual ~CxxFrameworkPathDetector();
virtual std::vector<FilePath> getPaths() const;
private:
const std::string m_compilerName;
};
#endif // CXX_FRAMEWORK_PATH_DETECTOR_H
src/lib_gui/utility/path_detector/cxx_header/CxxHeaderPathDetector.cpp
+29
View File
@@ -0,0 +1,29 @@
#include "utility/path_detector/cxx_header/CxxHeaderPathDetector.h"
#include "utility/path_detector/cxx_header/utilityCxxHeaderDetection.h"
#include "utility/utilityApp.h"
#include "utility/utilityString.h"
CxxHeaderPathDetector::CxxHeaderPathDetector(const std::string& compilerName)
: PathDetector(compilerName)
, m_compilerName(compilerName)
{
}
CxxHeaderPathDetector::~CxxHeaderPathDetector()
{
}
std::vector<FilePath> CxxHeaderPathDetector::getPaths() const
{
std::vector<std::string> paths = utility::getCxxHeaderPaths(m_compilerName);
std::vector<FilePath> headerPaths;
for (const std::string& path : paths)
{
if (!utility::isPostfix(" (framework directory)", path))
{
headerPaths.push_back(FilePath(path).canonical());
}
}
return headerPaths;
}
src/lib_gui/utility/path_detector/cxx_header/CxxHeaderPathDetector.h
+18
View File
@@ -0,0 +1,18 @@
#ifndef CXX_HEADER_PATH_DETECTOR_H
#define CXX_HEADER_PATH_DETECTOR_H
#include "utility/path_detector/PathDetector.h"
class CxxHeaderPathDetector: public PathDetector
{
public:
CxxHeaderPathDetector(const std::string& compilerName);
virtual ~CxxHeaderPathDetector();
virtual std::vector<FilePath> getPaths() const;
private:
const std::string m_compilerName;
};
#endif // CXX_HEADER_PATH_DETECTOR_H
src/lib_gui/utility/headerSearch/VisualStudioDetector.cpp → src/lib_gui/utility/path_detector/cxx_header/CxxVsHeaderPathDetector.cpp
+7 -12
View File
@@ -1,4 +1,4 @@
#include "utility/headerSearch/VisualStudioDetector.h"
#include "utility/path_detector/cxx_header/CxxVsHeaderPathDetector.h"
#include <string>
@@ -8,18 +8,18 @@
#include "utility/file/FilePath.h"
#include "utility/logging/logging.h"
VisualStudioDetector::VisualStudioDetector(const std::string name, int version, bool isExpress)
: DetectorBase(name)
CxxVsHeaderPathDetector::CxxVsHeaderPathDetector(int version, bool isExpress)
: PathDetector("Visual Studio " + std::to_string(version) + (isExpress ? " Express" : ""))
, m_version(version)
, m_isExpress(isExpress)
{
}
VisualStudioDetector::~VisualStudioDetector()
CxxVsHeaderPathDetector::~CxxVsHeaderPathDetector()
{
}
std::vector<FilePath> VisualStudioDetector::getStandardHeaderPaths()
std::vector<FilePath> CxxVsHeaderPathDetector::getPaths() const
{
FilePath vsInstallPath = getVsInstallPathUsingRegistry();
@@ -86,12 +86,7 @@ std::vector<FilePath> VisualStudioDetector::getStandardHeaderPaths()
return headerPaths;
}
std::vector<FilePath> VisualStudioDetector::getStandardFrameworkPaths()
{
return std::vector<FilePath>();
}
FilePath VisualStudioDetector::getVsInstallPathUsingRegistry()
FilePath CxxVsHeaderPathDetector::getVsInstallPathUsingRegistry() const
{
QString key = "HKEY_LOCAL_MACHINE\\SOFTWARE\\";
if (QSysInfo::currentCpuArchitecture() == "x86_64")
@@ -114,7 +109,7 @@ FilePath VisualStudioDetector::getVsInstallPathUsingRegistry()
return FilePath();
}
FilePath VisualStudioDetector::getWindowsSdkPathUsingRegistry(const std::string& version)
FilePath CxxVsHeaderPathDetector::getWindowsSdkPathUsingRegistry(const std::string& version) const
{
QString key(("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\" + version).c_str());
src/lib_gui/utility/path_detector/cxx_header/CxxVsHeaderPathDetector.h
+22
View File
@@ -0,0 +1,22 @@
#ifndef CXX_VS_HEADER_PATH_DETECTOR_H
#define CXX_VS_HEADER_PATH_DETECTOR_H
#include "utility/path_detector/PathDetector.h"
class CxxVsHeaderPathDetector: public PathDetector
{
public:
CxxVsHeaderPathDetector(int version, bool isExpress);
virtual ~CxxVsHeaderPathDetector();
virtual std::vector<FilePath> getPaths() const;
private:
FilePath getVsInstallPathUsingRegistry() const;
FilePath getWindowsSdkPathUsingRegistry(const std::string& version) const;
const int m_version;
const bool m_isExpress;
};
#endif // CXX_VS_HEADER_PATH_DETECTOR_H
src/lib_gui/utility/path_detector/cxx_header/utilityCxxHeaderDetection.cpp
+26
View File
@@ -0,0 +1,26 @@
#include "utility/path_detector/cxx_header/utilityCxxHeaderDetection.h"
#include "utility/utilityApp.h"
#include "utility/utilityString.h"
namespace utility
{
std::vector<std::string> getCxxHeaderPaths(const std::string& compilerName)
{
std::string command = compilerName + " -x c++ -v -E /dev/null";
std::string clangOutput = utility::executeProcess(command.c_str());
std::string standardHeaders =
utility::substrBetween(clangOutput, "#include <...> search starts here:\n","\nEnd of search list");
std::vector<std::string> paths;
if (!standardHeaders.empty())
{
for (std::string s : utility::splitToVector(standardHeaders, '\n'))
{
paths.push_back(utility::trim(s));
}
}
return paths;
}
}
src/lib_gui/utility/path_detector/cxx_header/utilityCxxHeaderDetection.h
+12
View File
@@ -0,0 +1,12 @@
#ifndef UTILITY_CXX_HEADER_DETECTION_H
#define UTILITY_CXX_HEADER_DETECTION_H
#include <string>
#include <vector>
namespace utility
{
std::vector<std::string> getCxxHeaderPaths(const std::string& compilerName);
}
#endif // UTILITY_CXX_HEADER_DETECTION_H
src/lib_gui/utility/path_detector/java_runtime/JavaPathDetector.cpp
+11
View File
@@ -0,0 +1,11 @@
#include "utility/path_detector/java_runtime/JavaPathDetector.h"
JavaPathDetector::JavaPathDetector(const std::string& name, const std::string& javaVersion)
: PathDetector(name)
, m_javaVersion(javaVersion)
{
}
JavaPathDetector::~JavaPathDetector()
{
}
src/lib_gui/utility/path_detector/java_runtime/JavaPathDetector.h
+17
View File
@@ -0,0 +1,17 @@
#ifndef JAVA_PATH_DETECTOR_H
#define JAVA_PATH_DETECTOR_H
#include "utility/path_detector/PathDetector.h"
#include "utility/file/FilePath.h"
class JavaPathDetector: public PathDetector
{
public:
JavaPathDetector(const std::string& name, const std::string& javaVersion);
virtual ~JavaPathDetector();
protected:
const std::string m_javaVersion;
};
#endif // JAVA_PATH_DETECTOR_H
src/lib_gui/utility/path_detector/java_runtime/JavaPathDetectorWindows.cpp
+34
View File
@@ -0,0 +1,34 @@
#include "utility/path_detector/java_runtime/JavaPathDetectorWindows.h"
#include <QSettings>
#include <QSysInfo>
JavaPathDetectorWindows::JavaPathDetectorWindows(const std::string javaVersion)
: JavaPathDetector("Java " + javaVersion + " for Windows", javaVersion)
{
}
JavaPathDetectorWindows::~JavaPathDetectorWindows()
{
}
std::vector<FilePath> JavaPathDetectorWindows::getPaths() const
{
QString key = "HKEY_LOCAL_MACHINE\\SOFTWARE\\";
key += "Wow6432Node\\"; // we need java 32 bit
key += ("JavaSoft\\Java Runtime Environment\\" + m_javaVersion).c_str();
QSettings expressKey(key, QSettings::NativeFormat); // NativeFormat means from Registry on Windows.
QString value = expressKey.value("RuntimeLib").toString();
FilePath path(value.toStdString());
std::vector<FilePath> paths;
if (path.exists())
{
paths.push_back(path.parentDirectory());
}
return paths;
}
src/lib_gui/utility/path_detector/java_runtime/JavaPathDetectorWindows.h
+15
View File
@@ -0,0 +1,15 @@
#ifndef JAVA_PATH_DETECTOR_WINDOWS_H
#define JAVA_PATH_DETECTOR_WINDOWS_H
#include "utility/path_detector/java_runtime/JavaPathDetector.h"
class JavaPathDetectorWindows: public JavaPathDetector
{
public:
JavaPathDetectorWindows(const std::string javaVersion);
virtual ~JavaPathDetectorWindows();
virtual std::vector<FilePath> getPaths() const;
};
#endif // JAVA_PATH_DETECTOR_WINDOWS_H
src/test/JavaParserTestSuite.h
+34 -22
View File
@@ -20,6 +20,14 @@ public:
///////////////////////////////////////////////////////////////////////////////
// test finding symbol definitions and declarations
void test_java_parser_can_setup_environment_factory()
{
setupJavaEnvironmentFactory();
// if this one fails, maybe your java_path in the test settings is wrong.
TS_ASSERT_LESS_THAN_EQUALS(1, JavaEnvironmentFactory::getInstance().use_count());
}
void test_java_parser_finds_package_declaration()
{
std::shared_ptr<TestParserClient> client = parseCode(
@@ -314,15 +322,15 @@ public:
TS_ASSERT_EQUALS(client->errors[0], "Encountered unexpected token. <1:1 1:7>");
}
void test_java_parser_finds_missing_import_as_error()
{
std::shared_ptr<TestParserClient> client = parseCode(
"import foo;\n"
);
//void _test_java_parser_finds_missing_import_as_error()
//{
// std::shared_ptr<TestParserClient> client = parseCode(
// "import foo;\n"
// );
TS_ASSERT_EQUALS(client->errors.size(), 1);
TS_ASSERT_EQUALS(client->errors[0], "Import not found. <1:8 1:10>");
}
// TS_ASSERT_EQUALS(client->errors.size(), 1);
// TS_ASSERT_EQUALS(client->errors[0], "Import not found. <1:8 1:10>");
//}
@@ -1173,23 +1181,10 @@ private:
};
std::shared_ptr<TestParserClient> parseCode(std::string code, bool logErrors = true)
void setupJavaEnvironmentFactory()
{
NameHierarchy::setDelimiter(".");
m_args.logErrors = logErrors;
m_args.language = "Java";
m_args.languageStandard = "1.8";
TestFileManager fm;
std::shared_ptr<FileRegister> fr = std::make_shared<FileRegister>(&fm, false);
std::shared_ptr<TestParserClient> client = std::make_shared<TestParserClient>();
std::shared_ptr<TextAccess> textAccess = TextAccess::createFromString(code);
if (!JavaEnvironmentFactory::getInstance())
{
#ifdef _WIN32
const std::string separator = ";";
#else
@@ -1206,6 +1201,23 @@ private:
"../app/data/java/java-symbol-solver-model.jar" + separator
);
}
}
std::shared_ptr<TestParserClient> parseCode(std::string code, bool logErrors = true)
{
NameHierarchy::setDelimiter(".");
m_args.logErrors = logErrors;
m_args.language = "Java";
m_args.languageStandard = "1.8";
TestFileManager fm;
std::shared_ptr<FileRegister> fr = std::make_shared<FileRegister>(&fm, false);
std::shared_ptr<TestParserClient> client = std::make_shared<TestParserClient>();
std::shared_ptr<TextAccess> textAccess = TextAccess::createFromString(code);
setupJavaEnvironmentFactory();
JavaParser parser(client.get());
parser.parseFile("input.cc", textAccess, m_args);