feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

C++: remove C/C++ distinction from ProjectPart fields.

Browse Source 
.. because they now hold only files for a single language+extensions
combination.

Task-number: QTCREATORBUG-11709
Task-number: QTCREATORBUG-12818
Change-Id: If294f6de07d60126be733d98de12b89b8af3efce
Reviewed-by: Nikolai Kosjar <nikolai.kosjar@digia.com>
This commit is contained in:
Erik Verbruggen
2014-08-21 16:26:06 +02:00
parent 193cb3b9a5
commit 990cedeb1b
13 changed files with 192 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
src/plugins/clangcodemodel/clangutils.cpp
View File

@@ -164,27 +164,11 @@ static QString getResourceDir()
*/ */
QStringList createClangOptions(const ProjectPart::Ptr &pPart, ProjectFile::Kind fileKind) QStringList createClangOptions(const ProjectPart::Ptr &pPart, ProjectFile::Kind fileKind)
{ {
QStringList result = clangLanguageOption(fileKind); const bool objcExt = pPart->languageExtensions & ProjectPart::ObjectiveCExtensions;
switch (fileKind) { QStringList result = clangLanguageOption(fileKind, objcExt);
default: result << clangOptionsForLanguage(pPart->qtVersion,
case CppTools::ProjectFile::CXXHeader: pPart->languageVersion,
case CppTools::ProjectFile::CXXSource: pPart->languageExtensions);
case CppTools::ProjectFile::ObjCXXHeader:
case CppTools::ProjectFile::ObjCXXSource:
case CppTools::ProjectFile::CudaSource:
case CppTools::ProjectFile::OpenCLSource:
result << clangOptionsForCxx(pPart->qtVersion,
pPart->cxxVersion,
pPart->cxxExtensions);
break;
case CppTools::ProjectFile::CHeader:
case CppTools::ProjectFile::CSource:
case CppTools::ProjectFile::ObjCHeader:
case CppTools::ProjectFile::ObjCSource:
result << clangOptionsForC(pPart->cVersion,
pPart->cxxExtensions);
break;
}
if (pPart.isNull()) if (pPart.isNull())
return result; return result;
@@ -204,6 +188,7 @@ QStringList createClangOptions(const ProjectPart::Ptr &pPart, ProjectFile::Kind
result << QLatin1String("-fdiagnostics-show-note-include-stack"); result << QLatin1String("-fdiagnostics-show-note-include-stack");
result << QLatin1String("-fmacro-backtrace-limit=0"); result << QLatin1String("-fmacro-backtrace-limit=0");
result << QLatin1String("-fretain-comments-from-system-headers"); result << QLatin1String("-fretain-comments-from-system-headers");
// TODO: -Xclang -ferror-limit -Xclang 0 ?
if (!pPart->projectConfigFile.isEmpty()) if (!pPart->projectConfigFile.isEmpty())
result << QLatin1String("-include") << pPart->projectConfigFile; result << QLatin1String("-include") << pPart->projectConfigFile;
@@ -263,57 +248,45 @@ QStringList createPCHInclusionOptions(const QString &pchFile)
} }
/// @return "-std" flag to select standard, flags for C extensions /// @return "-std" flag to select standard, flags for C extensions
QStringList clangOptionsForC(ProjectPart::CVersion cVersion, ProjectPart::CXXExtensions cxxExtensions) /// @return "-std" flag to select standard, flags for C++ extensions, Qt injections
QStringList clangOptionsForLanguage(CppTools::ProjectPart::QtVersion qtVersion,
CppTools::ProjectPart::LanguageVersion languageVersion,
ProjectPart::LanguageExtensions languageExtensions)
{ {
QStringList opts; QStringList opts;
bool gnuExpensions = cxxExtensions & ProjectPart::GnuExtensions; bool gnuExtensions = languageExtensions & ProjectPart::GnuExtensions;
switch (cVersion) { switch (languageVersion) {
case ProjectPart::C89: case ProjectPart::C89:
opts << (gnuExpensions ? QLatin1String("-std=gnu89") : QLatin1String("-std=c89")); opts << (gnuExtensions ? QLatin1String("-std=gnu89") : QLatin1String("-std=c89"));
break; break;
case ProjectPart::C99: case ProjectPart::C99:
opts << (gnuExpensions ? QLatin1String("-std=gnu99") : QLatin1String("-std=c99")); opts << (gnuExtensions ? QLatin1String("-std=gnu99") : QLatin1String("-std=c99"));
break; break;
case ProjectPart::C11: case ProjectPart::C11:
opts << (gnuExpensions ? QLatin1String("-std=gnu11") : QLatin1String("-std=c11")); opts << (gnuExtensions ? QLatin1String("-std=gnu11") : QLatin1String("-std=c11"));
break; break;
}
if (cxxExtensions & ProjectPart::MicrosoftExtensions) {
opts << QLatin1String("-fms-extensions");
}
#if defined(CINDEX_VERSION) // clang 3.2 or higher
if (cxxExtensions & ProjectPart::BorlandExtensions)
opts << QLatin1String("-fborland-extensions");
#endif
return opts;
}
/// @return "-std" flag to select standard, flags for C++ extensions, Qt injections
QStringList clangOptionsForCxx(ProjectPart::QtVersion qtVersion,
ProjectPart::CXXVersion cxxVersion,
ProjectPart::CXXExtensions cxxExtensions)
{
QStringList opts;
bool gnuExpensions = cxxExtensions & ProjectPart::GnuExtensions;
switch (cxxVersion) {
case ProjectPart::CXX11: case ProjectPart::CXX11:
opts << (gnuExpensions ? QLatin1String("-std=gnu++11") : QLatin1String("-std=c++11")); opts << (gnuExtensions ? QLatin1String("-std=gnu++11") : QLatin1String("-std=c++11"));
break; break;
case ProjectPart::CXX98: case ProjectPart::CXX98:
opts << (gnuExpensions ? QLatin1String("-std=gnu++98") : QLatin1String("-std=c++98")); opts << (gnuExtensions ? QLatin1String("-std=gnu++98") : QLatin1String("-std=c++98"));
break;
case ProjectPart::CXX03:
opts << QLatin1String("-std=c++03");
break;
case ProjectPart::CXX14:
opts << QLatin1String("-std=c++1y"); // TODO: change to c++14 after 3.5
break;
case ProjectPart::CXX17:
opts << QLatin1String("-std=c++1z"); // TODO: change to c++17 at some point in the future
break; break;
} }
if (cxxExtensions & ProjectPart::MicrosoftExtensions) { if (languageExtensions & ProjectPart::MicrosoftExtensions)
opts << QLatin1String("-fms-extensions") opts << QLatin1String("-fms-extensions");
<< QLatin1String("-fdelayed-template-parsing");
}
#if defined(CINDEX_VERSION) // clang 3.2 or higher #if defined(CINDEX_VERSION) // clang 3.2 or higher
if (cxxExtensions & ProjectPart::BorlandExtensions) if (languageExtensions & ProjectPart::BorlandExtensions)
opts << QLatin1String("-fborland-extensions"); opts << QLatin1String("-fborland-extensions");
#endif #endif
@@ -327,37 +300,48 @@ QStringList clangOptionsForCxx(ProjectPart::QtVersion qtVersion,
} }
/// @return "-x language-code" /// @return "-x language-code"
QStringList clangLanguageOption(ProjectFile::Kind fileKind) QStringList clangLanguageOption(ProjectFile::Kind fileKind, bool objcExt)
{ {
QStringList opts; QStringList opts;
opts += QLatin1String("-x"); opts += QLatin1String("-x");
switch (fileKind) { switch (fileKind) {
case ProjectFile::CHeader: case ProjectFile::CHeader:
// opts += QLatin1String("c-header"); if (objcExt)
// break; opts += QLatin1String("objective-c-header");
else
opts += QLatin1String("c-header");
break;
case ProjectFile::CXXHeader: case ProjectFile::CXXHeader:
default: default:
opts += QLatin1String("c++-header"); if (!objcExt) {
break; opts += QLatin1String("c++-header");
case ProjectFile::CXXSource: break;
opts += QLatin1String("c++"); } // else: fall-through!
break;
case ProjectFile::CSource:
opts += QLatin1String("c");
break;
case ProjectFile::ObjCHeader: case ProjectFile::ObjCHeader:
// opts += QLatin1String("objective-c-header");
// break;
case ProjectFile::ObjCXXHeader: case ProjectFile::ObjCXXHeader:
opts += QLatin1String("objective-c++-header"); opts += QLatin1String("objective-c++-header");
break; break;
case ProjectFile::CSource:
if (!objcExt) {
opts += QLatin1String("c");
break;
} // else: fall-through!
case ProjectFile::ObjCSource: case ProjectFile::ObjCSource:
opts += QLatin1String("objective-c"); opts += QLatin1String("objective-c");
break; break;
case ProjectFile::CXXSource:
if (!objcExt) {
opts += QLatin1String("c++");
break;
} // else: fall-through!
case ProjectFile::ObjCXXSource: case ProjectFile::ObjCXXSource:
opts += QLatin1String("objective-c++"); opts += QLatin1String("objective-c++");
break; break;
case ProjectFile::OpenCLSource: case ProjectFile::OpenCLSource:
opts += QLatin1String("cl"); opts += QLatin1String("cl");
break; break;

10
src/plugins/clangcodemodel/clangutils.h
View File

@@ -45,12 +45,10 @@ QStringList clangNonProjectFileOptions(CppTools::ProjectFile::Kind kind);
QStringList createPCHInclusionOptions(const QStringList &pchFiles); QStringList createPCHInclusionOptions(const QStringList &pchFiles);
QStringList createPCHInclusionOptions(const QString &pchFile); QStringList createPCHInclusionOptions(const QString &pchFile);
QStringList clangLanguageOption(CppTools::ProjectFile::Kind fileKind); QStringList clangLanguageOption(CppTools::ProjectFile::Kind fileKind, bool objcExt);
QStringList clangOptionsForC(CppTools::ProjectPart::CVersion cVersion, QStringList clangOptionsForLanguage(CppTools::ProjectPart::QtVersion qtVersion,
CppTools::ProjectPart::CXXExtensions cxxExtensions); CppTools::ProjectPart::LanguageVersion languageVersion,
QStringList clangOptionsForCxx(CppTools::ProjectPart::QtVersion qtVersion, CppTools::ProjectPart::LanguageExtensions languageExtensions);
CppTools::ProjectPart::CXXVersion cxxVersion,
CppTools::ProjectPart::CXXExtensions cxxExtensions);
} // namespace Utils } // namespace Utils
} // namespace Clang } // namespace Clang

21
src/plugins/clangcodemodel/pchmanager.cpp
View File

@@ -253,9 +253,8 @@ void PchManager::doPchInfoUpdateFuzzy(QFutureInterface<void> &future,
QHash<QString, bool> objc; QHash<QString, bool> objc;
QHash<QString, bool> cplusplus; QHash<QString, bool> cplusplus;
QHash<QString, ProjectPart::QtVersion> qtVersions; QHash<QString, ProjectPart::QtVersion> qtVersions;
QHash<QString, ProjectPart::CVersion> cVersions; QHash<QString, ProjectPart::LanguageVersion> languageVersions;
QHash<QString, ProjectPart::CXXVersion> cxxVersions; QHash<QString, ProjectPart::LanguageExtensions> languageExtensionsMap;
QHash<QString, ProjectPart::CXXExtensions> cxxExtensionsMap;
QHash<QString, QList<ProjectPart::Ptr> > inputToParts; QHash<QString, QList<ProjectPart::Ptr> > inputToParts;
foreach (const ProjectPart::Ptr &projectPart, params.projectParts) { foreach (const ProjectPart::Ptr &projectPart, params.projectParts) {
if (projectPart->precompiledHeaders.isEmpty()) if (projectPart->precompiledHeaders.isEmpty())
@@ -266,9 +265,9 @@ void PchManager::doPchInfoUpdateFuzzy(QFutureInterface<void> &future,
inputToParts[pch].append(projectPart); inputToParts[pch].append(projectPart);
headers[pch].unite(QSet<HeaderPath>::fromList(projectPart->headerPaths)); headers[pch].unite(QSet<HeaderPath>::fromList(projectPart->headerPaths));
cVersions[pch] = std::max(cVersions.value(pch, ProjectPart::C89), projectPart->cVersion); languageVersions[pch] = std::max(languageVersions.value(pch, ProjectPart::C89),
cxxVersions[pch] = std::max(cxxVersions.value(pch, ProjectPart::CXX98), projectPart->cxxVersion); projectPart->languageVersion);
cxxExtensionsMap[pch] = cxxExtensionsMap[pch] | projectPart->cxxExtensions; languageExtensionsMap[pch] = languageExtensionsMap[pch] | projectPart->languageExtensions;
if (hasObjCFiles(projectPart)) if (hasObjCFiles(projectPart))
objc[pch] = true; objc[pch] = true;
@@ -301,9 +300,8 @@ void PchManager::doPchInfoUpdateFuzzy(QFutureInterface<void> &future,
return; return;
ProjectPart::Ptr projectPart(new ProjectPart); ProjectPart::Ptr projectPart(new ProjectPart);
projectPart->qtVersion = qtVersions[pch]; projectPart->qtVersion = qtVersions[pch];
projectPart->cVersion = cVersions[pch]; projectPart->languageVersion = languageVersions[pch];
projectPart->cxxVersion = cxxVersions[pch]; projectPart->languageExtensions = languageExtensionsMap[pch];
projectPart->cxxExtensions = cxxExtensionsMap[pch];
projectPart->headerPaths = headers[pch].toList(); projectPart->headerPaths = headers[pch].toList();
QList<QByteArray> defines = definesPerPCH[pch].toList(); QList<QByteArray> defines = definesPerPCH[pch].toList();
@@ -379,11 +377,10 @@ void PchManager::doPchInfoUpdateCustom(QFutureInterface<void> &future,
bool objc = false; bool objc = false;
bool cplusplus = false; bool cplusplus = false;
ProjectPart::Ptr united(new ProjectPart()); ProjectPart::Ptr united(new ProjectPart());
united->cxxVersion = ProjectPart::CXX98; united->languageVersion = ProjectPart::C89;
foreach (const ProjectPart::Ptr &projectPart, params.projectParts) { foreach (const ProjectPart::Ptr &projectPart, params.projectParts) {
headers += projectPart->headerPaths; headers += projectPart->headerPaths;
united->cVersion = std::max(united->cVersion, projectPart->cVersion); united->languageVersion = std::max(united->languageVersion, projectPart->languageVersion);
united->cxxVersion = std::max(united->cxxVersion, projectPart->cxxVersion);
united->qtVersion = std::max(united->qtVersion, projectPart->qtVersion); united->qtVersion = std::max(united->qtVersion, projectPart->qtVersion);
objc |= hasObjCFiles(projectPart); objc |= hasObjCFiles(projectPart);
cplusplus |= hasCppFiles(projectPart); cplusplus |= hasCppFiles(projectPart);

10
src/plugins/cppeditor/cppcodemodelinspectordialog.cpp
View File

@@ -1619,12 +1619,10 @@ void CppCodeModelInspectorDialog::updateProjectPartData(const ProjectPart::Ptr &
QDir::toNativeSeparators(part->projectFile)) QDir::toNativeSeparators(part->projectFile))
<< qMakePair(QString::fromLatin1("Project Name"), projectName) << qMakePair(QString::fromLatin1("Project Name"), projectName)
<< qMakePair(QString::fromLatin1("Project File"), projectFilePath) << qMakePair(QString::fromLatin1("Project File"), projectFilePath)
<< qMakePair(QString::fromLatin1("C Version"), << qMakePair(QString::fromLatin1("Language Version"),
CMI::Utils::toString(part->cVersion)) CMI::Utils::toString(part->languageVersion))
<< qMakePair(QString::fromLatin1("CXX Version"), << qMakePair(QString::fromLatin1("Language Extensions"),
CMI::Utils::toString(part->cxxVersion)) CMI::Utils::toString(part->languageExtensions))
<< qMakePair(QString::fromLatin1("CXX Extensions"),
CMI::Utils::toString(part->cxxExtensions))
<< qMakePair(QString::fromLatin1("Qt Version"), << qMakePair(QString::fromLatin1("Qt Version"),
CMI::Utils::toString(part->qtVersion)) CMI::Utils::toString(part->qtVersion))
; ;

62
src/plugins/cpptools/cppcodemodelinspectordumper.cpp
View File

@@ -90,44 +90,38 @@ QString Utils::toString(CPlusPlus::Document::DiagnosticMessage::Level level)
return QString(); return QString();
} }
QString Utils::toString(ProjectPart::CVersion cVersion) QString Utils::toString(ProjectPart::LanguageVersion languageVersion)
{ {
#define CASE_CVERSION(x) case ProjectPart::x: return QLatin1String(#x) #define CASE_LANGUAGEVERSION(x) case ProjectPart::x: return QLatin1String(#x)
switch (cVersion) { switch (languageVersion) {
CASE_CVERSION(C89); CASE_LANGUAGEVERSION(C89);
CASE_CVERSION(C99); CASE_LANGUAGEVERSION(C99);
CASE_CVERSION(C11); CASE_LANGUAGEVERSION(C11);
CASE_LANGUAGEVERSION(CXX98);
CASE_LANGUAGEVERSION(CXX03);
CASE_LANGUAGEVERSION(CXX11);
CASE_LANGUAGEVERSION(CXX14);
CASE_LANGUAGEVERSION(CXX17);
// no default to get a compiler warning if anything is added // no default to get a compiler warning if anything is added
} }
#undef CASE_CVERSION #undef CASE_LANGUAGEVERSION
return QString(); return QString();
} }
QString Utils::toString(ProjectPart::CXXVersion cxxVersion) QString Utils::toString(ProjectPart::LanguageExtensions languageExtension)
{
#define CASE_CXXVERSION(x) case ProjectPart::x: return QLatin1String(#x)
switch (cxxVersion) {
CASE_CXXVERSION(CXX98);
CASE_CXXVERSION(CXX11);
// no default to get a compiler warning if anything is added
}
#undef CASE_CXXVERSION
return QString();
}
QString Utils::toString(ProjectPart::CXXExtensions cxxExtension)
{ {
QString result; QString result;
#define CASE_CXXEXTENSION(ext) if (cxxExtension & ProjectPart::ext) \ #define CASE_LANGUAGE_EXTENSION(ext) if (languageExtension & ProjectPart::ext) \
result += QLatin1String(#ext ", "); result += QLatin1String(#ext ", ");
CASE_CXXEXTENSION(NoExtensions); CASE_LANGUAGE_EXTENSION(NoExtensions);
CASE_CXXEXTENSION(GnuExtensions); CASE_LANGUAGE_EXTENSION(GnuExtensions);
CASE_CXXEXTENSION(MicrosoftExtensions); CASE_LANGUAGE_EXTENSION(MicrosoftExtensions);
CASE_CXXEXTENSION(BorlandExtensions); CASE_LANGUAGE_EXTENSION(BorlandExtensions);
CASE_CXXEXTENSION(OpenMPExtensions); CASE_LANGUAGE_EXTENSION(OpenMPExtensions);
#undef CASE_CXXEXTENSION CASE_LANGUAGE_EXTENSION(ObjectiveCExtensions);
#undef CASE_LANGUAGE_EXTENSION
if (result.endsWith(QLatin1String(", "))) if (result.endsWith(QLatin1String(", ")))
result.chop(2); result.chop(2);
return result; return result;
@@ -496,13 +490,13 @@ void Dumper::dumpProjectInfos( const QList<ProjectInfo> &projectInfos)
if (!part->projectConfigFile.isEmpty()) if (!part->projectConfigFile.isEmpty())
m_out << i3 << "Project Config File: " << part->projectConfigFile << "\n"; m_out << i3 << "Project Config File: " << part->projectConfigFile << "\n";
m_out << i2 << "Project Part \"" << part->projectFile << "\"{{{3\n"; m_out << i2 << "Project Part \"" << part->projectFile << "\"{{{3\n";
m_out << i3 << "Project Part Name : " << part->displayName << "\n"; m_out << i3 << "Project Part Name : " << part->displayName << "\n";
m_out << i3 << "Project Name : " << projectName << "\n"; m_out << i3 << "Project Name : " << projectName << "\n";
m_out << i3 << "Project File : " << projectFilePath << "\n"; m_out << i3 << "Project File : " << projectFilePath << "\n";
m_out << i3 << "C Version : " << Utils::toString(part->cVersion) << "\n"; m_out << i3 << "Lanugage Version : " << Utils::toString(part->languageVersion)<<"\n";
m_out << i3 << "CXX Version : " << Utils::toString(part->cxxVersion) << "\n"; m_out << i3 << "Lanugage Extensions : " << Utils::toString(part->languageExtensions)
m_out << i3 << "CXX Extensions : " << Utils::toString(part->cxxExtensions) << "\n"; << "\n";
m_out << i3 << "Qt Version : " << Utils::toString(part->qtVersion) << "\n"; m_out << i3 << "Qt Version : " << Utils::toString(part->qtVersion) << "\n";
if (!part->files.isEmpty()) { if (!part->files.isEmpty()) {
m_out << i3 << "Files:{{{4\n"; m_out << i3 << "Files:{{{4\n";

5
src/plugins/cpptools/cppcodemodelinspectordumper.h
View File

@@ -48,9 +48,8 @@ struct CPPTOOLS_EXPORT Utils
static QString toString(const QDateTime &dateTime); static QString toString(const QDateTime &dateTime);
static QString toString(CPlusPlus::Document::CheckMode checkMode); static QString toString(CPlusPlus::Document::CheckMode checkMode);
static QString toString(CPlusPlus::Document::DiagnosticMessage::Level level); static QString toString(CPlusPlus::Document::DiagnosticMessage::Level level);
static QString toString(CppTools::ProjectPart::CVersion cVersion); static QString toString(CppTools::ProjectPart::LanguageVersion languageVersion);
static QString toString(CppTools::ProjectPart::CXXVersion cxxVersion); static QString toString(CppTools::ProjectPart::LanguageExtensions languageExtension);
static QString toString(CppTools::ProjectPart::CXXExtensions cxxExtension);
static QString toString(CppTools::ProjectPart::QtVersion qtVersion); static QString toString(CppTools::ProjectPart::QtVersion qtVersion);
static QString toString(const QList<CppTools::ProjectFile> &projectFiles); static QString toString(const QList<CppTools::ProjectFile> &projectFiles);
static QString toString(CppTools::ProjectFile::Kind kind); static QString toString(CppTools::ProjectFile::Kind kind);

5
src/plugins/cpptools/cppmodelmanager.cpp
View File

@@ -746,9 +746,8 @@ ProjectPart::Ptr CppModelManager::fallbackProjectPart() const
part->projectDefines = m_definedMacros; part->projectDefines = m_definedMacros;
part->headerPaths = m_headerPaths; part->headerPaths = m_headerPaths;
part->cVersion = ProjectPart::C11; part->languageVersion = ProjectPart::CXX14;
part->cxxVersion = ProjectPart::CXX11; part->languageExtensions = ProjectPart::AllExtensions;
part->cxxExtensions = ProjectPart::AllExtensions;
part->qtVersion = ProjectPart::Qt5; part->qtVersion = ProjectPart::Qt5;
return part; return part;

32
src/plugins/cpptools/cppmodelmanager_test.cpp
View File

@@ -97,7 +97,7 @@ public:
QCOMPARE(projectInfo.project().data(), project); QCOMPARE(projectInfo.project().data(), project);
ProjectPart::Ptr part(new ProjectPart); ProjectPart::Ptr part(new ProjectPart);
part->cxxVersion = ProjectPart::CXX98; part->languageVersion = ProjectPart::CXX14;
part->qtVersion = ProjectPart::Qt5; part->qtVersion = ProjectPart::Qt5;
foreach (const QString &file, projectFiles) { foreach (const QString &file, projectFiles) {
ProjectFile projectFile(file, ProjectFile::classify(file)); ProjectFile projectFile(file, ProjectFile::classify(file));
@@ -221,7 +221,7 @@ void CppToolsPlugin::test_modelmanager_paths_are_clean()
typedef ProjectPart::HeaderPath HeaderPath; typedef ProjectPart::HeaderPath HeaderPath;
ProjectPart::Ptr part(new ProjectPart); ProjectPart::Ptr part(new ProjectPart);
part->cxxVersion = ProjectPart::CXX98; part->languageVersion = ProjectPart::CXX14;
part->qtVersion = ProjectPart::Qt5; part->qtVersion = ProjectPart::Qt5;
part->projectDefines = QByteArray("#define OH_BEHAVE -1\n"); part->projectDefines = QByteArray("#define OH_BEHAVE -1\n");
part->headerPaths = QList<HeaderPath>() part->headerPaths = QList<HeaderPath>()
@@ -257,7 +257,7 @@ void CppToolsPlugin::test_modelmanager_framework_headers()
typedef ProjectPart::HeaderPath HeaderPath; typedef ProjectPart::HeaderPath HeaderPath;
ProjectPart::Ptr part(new ProjectPart); ProjectPart::Ptr part(new ProjectPart);
part->cxxVersion = ProjectPart::CXX98; part->languageVersion = ProjectPart::CXX14;
part->qtVersion = ProjectPart::Qt5; part->qtVersion = ProjectPart::Qt5;
part->projectDefines = QByteArray("#define OH_BEHAVE -1\n"); part->projectDefines = QByteArray("#define OH_BEHAVE -1\n");
part->headerPaths = QList<HeaderPath>() part->headerPaths = QList<HeaderPath>()
@@ -310,7 +310,7 @@ void CppToolsPlugin::test_modelmanager_refresh_also_includes_of_project_files()
typedef ProjectPart::HeaderPath HeaderPath; typedef ProjectPart::HeaderPath HeaderPath;
ProjectPart::Ptr part(new ProjectPart); ProjectPart::Ptr part(new ProjectPart);
part->cxxVersion = ProjectPart::CXX98; part->languageVersion = ProjectPart::CXX14;
part->qtVersion = ProjectPart::Qt5; part->qtVersion = ProjectPart::Qt5;
part->projectDefines = QByteArray("#define OH_BEHAVE -1\n"); part->projectDefines = QByteArray("#define OH_BEHAVE -1\n");
part->headerPaths = QList<HeaderPath>() part->headerPaths = QList<HeaderPath>()
@@ -371,7 +371,7 @@ void CppToolsPlugin::test_modelmanager_refresh_several_times()
QCOMPARE(pi.project().data(), project); QCOMPARE(pi.project().data(), project);
ProjectPart::Ptr part(new ProjectPart); ProjectPart::Ptr part(new ProjectPart);
part->cxxVersion = ProjectPart::CXX98; part->languageVersion = ProjectPart::CXX14;
part->qtVersion = ProjectPart::Qt5; part->qtVersion = ProjectPart::Qt5;
part->files.append(ProjectFile(testHeader1, ProjectFile::CXXHeader)); part->files.append(ProjectFile(testHeader1, ProjectFile::CXXHeader));
part->files.append(ProjectFile(testHeader2, ProjectFile::CXXHeader)); part->files.append(ProjectFile(testHeader2, ProjectFile::CXXHeader));
@@ -391,7 +391,7 @@ void CppToolsPlugin::test_modelmanager_refresh_several_times()
// Simulate project configuration change by having different defines each time. // Simulate project configuration change by having different defines each time.
defines += "\n#define ANOTHER_DEFINE"; defines += "\n#define ANOTHER_DEFINE";
part->projectDefines = defines; part->projectDefines = defines;
part->cxxVersion = ProjectPart::CXX98; part->languageVersion = ProjectPart::CXX14;
part->qtVersion = ProjectPart::Qt5; part->qtVersion = ProjectPart::Qt5;
part->files.append(ProjectFile(testHeader1, ProjectFile::CXXHeader)); part->files.append(ProjectFile(testHeader1, ProjectFile::CXXHeader));
part->files.append(ProjectFile(testHeader2, ProjectFile::CXXHeader)); part->files.append(ProjectFile(testHeader2, ProjectFile::CXXHeader));
@@ -438,7 +438,7 @@ void CppToolsPlugin::test_modelmanager_refresh_test_for_changes()
QCOMPARE(pi.project().data(), project); QCOMPARE(pi.project().data(), project);
ProjectPart::Ptr part(new ProjectPart); ProjectPart::Ptr part(new ProjectPart);
part->cxxVersion = ProjectPart::CXX98; part->languageVersion = ProjectPart::CXX14;
part->qtVersion = ProjectPart::Qt5; part->qtVersion = ProjectPart::Qt5;
part->files.append(ProjectFile(testCpp, ProjectFile::CXXSource)); part->files.append(ProjectFile(testCpp, ProjectFile::CXXSource));
pi.appendProjectPart(part); pi.appendProjectPart(part);
@@ -476,7 +476,7 @@ void CppToolsPlugin::test_modelmanager_refresh_added_and_purge_removed()
QCOMPARE(pi.project().data(), project); QCOMPARE(pi.project().data(), project);
ProjectPart::Ptr part(new ProjectPart); ProjectPart::Ptr part(new ProjectPart);
part->cxxVersion = ProjectPart::CXX98; part->languageVersion = ProjectPart::CXX14;
part->qtVersion = ProjectPart::Qt5; part->qtVersion = ProjectPart::Qt5;
part->files.append(ProjectFile(testCpp, ProjectFile::CXXSource)); part->files.append(ProjectFile(testCpp, ProjectFile::CXXSource));
part->files.append(ProjectFile(testHeader1, ProjectFile::CXXHeader)); part->files.append(ProjectFile(testHeader1, ProjectFile::CXXHeader));
@@ -499,7 +499,7 @@ void CppToolsPlugin::test_modelmanager_refresh_added_and_purge_removed()
// Now add testHeader2 and remove testHeader1 // Now add testHeader2 and remove testHeader1
pi.clearProjectParts(); pi.clearProjectParts();
ProjectPart::Ptr newPart(new ProjectPart); ProjectPart::Ptr newPart(new ProjectPart);
newPart->cxxVersion = ProjectPart::CXX98; newPart->languageVersion = ProjectPart::CXX14;
newPart->qtVersion = ProjectPart::Qt5; newPart->qtVersion = ProjectPart::Qt5;
newPart->files.append(ProjectFile(testCpp, ProjectFile::CXXSource)); newPart->files.append(ProjectFile(testCpp, ProjectFile::CXXSource));
newPart->files.append(ProjectFile(testHeader2, ProjectFile::CXXHeader)); newPart->files.append(ProjectFile(testHeader2, ProjectFile::CXXHeader));
@@ -535,7 +535,7 @@ void CppToolsPlugin::test_modelmanager_refresh_timeStampModified_if_sourcefiles_
QCOMPARE(pi.project().data(), project); QCOMPARE(pi.project().data(), project);
ProjectPart::Ptr part(new ProjectPart); ProjectPart::Ptr part(new ProjectPart);
part->cxxVersion = ProjectPart::CXX98; part->languageVersion = ProjectPart::CXX14;
part->qtVersion = ProjectPart::Qt5; part->qtVersion = ProjectPart::Qt5;
foreach (const ProjectFile &file, initialProjectFiles) foreach (const ProjectFile &file, initialProjectFiles)
part->files.append(file); part->files.append(file);
@@ -829,7 +829,7 @@ void CppToolsPlugin::test_modelmanager_defines_per_project()
part1->projectFile = QLatin1String("project1.projectfile"); part1->projectFile = QLatin1String("project1.projectfile");
part1->files.append(ProjectFile(main1File, ProjectFile::CXXSource)); part1->files.append(ProjectFile(main1File, ProjectFile::CXXSource));
part1->files.append(ProjectFile(header, ProjectFile::CXXHeader)); part1->files.append(ProjectFile(header, ProjectFile::CXXHeader));
part1->cxxVersion = ProjectPart::CXX11; part1->languageVersion = ProjectPart::CXX11;
part1->qtVersion = ProjectPart::NoQt; part1->qtVersion = ProjectPart::NoQt;
part1->projectDefines = QByteArray("#define SUB1\n"); part1->projectDefines = QByteArray("#define SUB1\n");
part1->headerPaths = QList<HeaderPath>() part1->headerPaths = QList<HeaderPath>()
@@ -839,7 +839,7 @@ void CppToolsPlugin::test_modelmanager_defines_per_project()
part2->projectFile = QLatin1String("project1.projectfile"); part2->projectFile = QLatin1String("project1.projectfile");
part2->files.append(ProjectFile(main2File, ProjectFile::CXXSource)); part2->files.append(ProjectFile(main2File, ProjectFile::CXXSource));
part2->files.append(ProjectFile(header, ProjectFile::CXXHeader)); part2->files.append(ProjectFile(header, ProjectFile::CXXHeader));
part2->cxxVersion = ProjectPart::CXX11; part2->languageVersion = ProjectPart::CXX11;
part2->qtVersion = ProjectPart::NoQt; part2->qtVersion = ProjectPart::NoQt;
part2->projectDefines = QByteArray("#define SUB2\n"); part2->projectDefines = QByteArray("#define SUB2\n");
part2->headerPaths = QList<HeaderPath>() part2->headerPaths = QList<HeaderPath>()
@@ -905,7 +905,7 @@ void CppToolsPlugin::test_modelmanager_precompiled_headers()
part1->projectFile = QLatin1String("project1.projectfile"); part1->projectFile = QLatin1String("project1.projectfile");
part1->files.append(ProjectFile(main1File, ProjectFile::CXXSource)); part1->files.append(ProjectFile(main1File, ProjectFile::CXXSource));
part1->files.append(ProjectFile(header, ProjectFile::CXXHeader)); part1->files.append(ProjectFile(header, ProjectFile::CXXHeader));
part1->cxxVersion = ProjectPart::CXX11; part1->languageVersion = ProjectPart::CXX11;
part1->qtVersion = ProjectPart::NoQt; part1->qtVersion = ProjectPart::NoQt;
part1->precompiledHeaders.append(pch1File); part1->precompiledHeaders.append(pch1File);
part1->headerPaths = QList<HeaderPath>() part1->headerPaths = QList<HeaderPath>()
@@ -915,7 +915,7 @@ void CppToolsPlugin::test_modelmanager_precompiled_headers()
part2->projectFile = QLatin1String("project2.projectfile"); part2->projectFile = QLatin1String("project2.projectfile");
part2->files.append(ProjectFile(main2File, ProjectFile::CXXSource)); part2->files.append(ProjectFile(main2File, ProjectFile::CXXSource));
part2->files.append(ProjectFile(header, ProjectFile::CXXHeader)); part2->files.append(ProjectFile(header, ProjectFile::CXXHeader));
part2->cxxVersion = ProjectPart::CXX11; part2->languageVersion = ProjectPart::CXX11;
part2->qtVersion = ProjectPart::NoQt; part2->qtVersion = ProjectPart::NoQt;
part2->precompiledHeaders.append(pch2File); part2->precompiledHeaders.append(pch2File);
part2->headerPaths = QList<HeaderPath>() part2->headerPaths = QList<HeaderPath>()
@@ -989,7 +989,7 @@ void CppToolsPlugin::test_modelmanager_defines_per_editor()
ProjectPart::Ptr part1(new ProjectPart); ProjectPart::Ptr part1(new ProjectPart);
part1->files.append(ProjectFile(main1File, ProjectFile::CXXSource)); part1->files.append(ProjectFile(main1File, ProjectFile::CXXSource));
part1->files.append(ProjectFile(header, ProjectFile::CXXHeader)); part1->files.append(ProjectFile(header, ProjectFile::CXXHeader));
part1->cxxVersion = ProjectPart::CXX11; part1->languageVersion = ProjectPart::CXX11;
part1->qtVersion = ProjectPart::NoQt; part1->qtVersion = ProjectPart::NoQt;
part1->headerPaths = QList<HeaderPath>() part1->headerPaths = QList<HeaderPath>()
<< HeaderPath(testDataDirectory.includeDir(false), HeaderPath::IncludePath); << HeaderPath(testDataDirectory.includeDir(false), HeaderPath::IncludePath);
@@ -997,7 +997,7 @@ void CppToolsPlugin::test_modelmanager_defines_per_editor()
ProjectPart::Ptr part2(new ProjectPart); ProjectPart::Ptr part2(new ProjectPart);
part2->files.append(ProjectFile(main2File, ProjectFile::CXXSource)); part2->files.append(ProjectFile(main2File, ProjectFile::CXXSource));
part2->files.append(ProjectFile(header, ProjectFile::CXXHeader)); part2->files.append(ProjectFile(header, ProjectFile::CXXHeader));
part2->cxxVersion = ProjectPart::CXX11; part2->languageVersion = ProjectPart::CXX11;
part2->qtVersion = ProjectPart::NoQt; part2->qtVersion = ProjectPart::NoQt;
part2->headerPaths = QList<HeaderPath>() part2->headerPaths = QList<HeaderPath>()
<< HeaderPath(testDataDirectory.includeDir(false), HeaderPath::IncludePath); << HeaderPath(testDataDirectory.includeDir(false), HeaderPath::IncludePath);

85
src/plugins/cpptools/cppprojects.cpp
View File

@@ -44,12 +44,10 @@ using namespace ProjectExplorer;
ProjectPart::ProjectPart() ProjectPart::ProjectPart()
: project(0) : project(0)
, cVersion(C89) , languageVersion(CXX14)
, cxxVersion(CXX11) , languageExtensions(NoExtensions)
, cxxExtensions(NoExtensions)
, qtVersion(UnknownQt) , qtVersion(UnknownQt)
, cWarningFlags(ProjectExplorer::ToolChain::WarningsDefault) , warningFlags(ProjectExplorer::ToolChain::WarningsDefault)
, cxxWarningFlags(ProjectExplorer::ToolChain::WarningsDefault)
{ {
} }
@@ -61,43 +59,42 @@ ProjectPart::ProjectPart()
\param cflags C or ObjectiveC flags if possible, \a cxxflags otherwise. \param cflags C or ObjectiveC flags if possible, \a cxxflags otherwise.
*/ */
void ProjectPart::evaluateToolchain(const ProjectExplorer::ToolChain *tc, void ProjectPart::evaluateToolchain(const ProjectExplorer::ToolChain *tc,
const QStringList &cxxflags, const QStringList &commandLineFlags,
const QStringList &cflags,
const Utils::FileName &sysRoot) const Utils::FileName &sysRoot)
{ {
if (!tc) if (!tc)
return; return;
using namespace ProjectExplorer; using namespace ProjectExplorer;
ToolChain::CompilerFlags cxx = tc->compilerFlags(cxxflags); ToolChain::CompilerFlags flags = tc->compilerFlags(commandLineFlags);
ToolChain::CompilerFlags c = (cxxflags == cflags)
? cxx : tc->compilerFlags(cflags);
if (c & ToolChain::StandardC11) if (flags & ToolChain::StandardC11)
cVersion = C11; languageVersion = C11;
else if (c & ToolChain::StandardC99) else if (flags & ToolChain::StandardC99)
cVersion = C99; languageVersion = C99;
else if (flags & ToolChain::StandardCxx17)
languageVersion = CXX17;
else if (flags & ToolChain::StandardCxx14)
languageVersion = CXX14;
else if (flags & ToolChain::StandardCxx11)
languageVersion = CXX11;
else else
cVersion = C89; languageVersion = CXX11;
if (cxx & ToolChain::StandardCxx11) if (flags & ToolChain::BorlandExtensions)
cxxVersion = CXX11; languageExtensions |= BorlandExtensions;
else if (flags & ToolChain::GnuExtensions)
cxxVersion = CXX98; languageExtensions |= GnuExtensions;
if (flags & ToolChain::MicrosoftExtensions)
languageExtensions |= MicrosoftExtensions;
if (flags & ToolChain::OpenMP)
languageExtensions |= OpenMPExtensions;
if (flags & ToolChain::ObjectiveC)
languageExtensions |= ObjectiveCExtensions;
if (cxx & ToolChain::BorlandExtensions) warningFlags = tc->warningFlags(commandLineFlags);
cxxExtensions |= BorlandExtensions;
if (cxx & ToolChain::GnuExtensions)
cxxExtensions |= GnuExtensions;
if (cxx & ToolChain::MicrosoftExtensions)
cxxExtensions |= MicrosoftExtensions;
if (cxx & ToolChain::OpenMP)
cxxExtensions |= OpenMPExtensions;
cWarningFlags = tc->warningFlags(cflags); const QList<ProjectExplorer::HeaderPath> headers = tc->systemHeaderPaths(commandLineFlags, sysRoot);
cxxWarningFlags = tc->warningFlags(cxxflags);
const QList<ProjectExplorer::HeaderPath> headers = tc->systemHeaderPaths(cxxflags, sysRoot);
foreach (const ProjectExplorer::HeaderPath &header, headers) { foreach (const ProjectExplorer::HeaderPath &header, headers) {
headerPaths << ProjectPart::HeaderPath(header.path(), headerPaths << ProjectPart::HeaderPath(header.path(),
header.kind() == ProjectExplorer::HeaderPath::FrameworkHeaderPath header.kind() == ProjectExplorer::HeaderPath::FrameworkHeaderPath
@@ -105,7 +102,7 @@ void ProjectPart::evaluateToolchain(const ProjectExplorer::ToolChain *tc,
: ProjectPart::HeaderPath::IncludePath); : ProjectPart::HeaderPath::IncludePath);
} }
toolchainDefines = tc->predefinedMacros(cxxflags); toolchainDefines = tc->predefinedMacros(commandLineFlags);
} }
ProjectPart::Ptr ProjectPart::copy() const ProjectPart::Ptr ProjectPart::copy() const
@@ -389,7 +386,7 @@ QList<Core::Id> ProjectPartBuilder::createProjectPartsForFiles(const QStringList
createProjectPart(cat.cSources(), createProjectPart(cat.cSources(),
cat.partName(QCoreApplication::translate("CppTools", "C11")), cat.partName(QCoreApplication::translate("CppTools", "C11")),
ProjectPart::C11, ProjectPart::C11,
ProjectPart::CXX11); ProjectPart::NoExtensions);
// TODO: there is no C... // TODO: there is no C...
// languages += ProjectExplorer::Constants::LANG_C; // languages += ProjectExplorer::Constants::LANG_C;
} }
@@ -397,22 +394,22 @@ QList<Core::Id> ProjectPartBuilder::createProjectPartsForFiles(const QStringList
createProjectPart(cat.objcSources(), createProjectPart(cat.objcSources(),
cat.partName(QCoreApplication::translate("CppTools", "Obj-C11")), cat.partName(QCoreApplication::translate("CppTools", "Obj-C11")),
ProjectPart::C11, ProjectPart::C11,
ProjectPart::CXX11); ProjectPart::ObjectiveCExtensions);
// TODO: there is no Ojective-C... // TODO: there is no Ojective-C...
// languages += ProjectExplorer::Constants::LANG_OBJC; // languages += ProjectExplorer::Constants::LANG_OBJC;
} }
if (cat.hasCxxSources()) { if (cat.hasCxxSources()) {
createProjectPart(cat.cxxSources(), createProjectPart(cat.cxxSources(),
cat.partName(QCoreApplication::translate("CppTools", "C++11")), cat.partName(QCoreApplication::translate("CppTools", "C++11")),
ProjectPart::C11, ProjectPart::CXX11,
ProjectPart::CXX11); ProjectPart::NoExtensions);
languages += ProjectExplorer::Constants::LANG_CXX; languages += ProjectExplorer::Constants::LANG_CXX;
} }
if (cat.hasObjcxxSources()) { if (cat.hasObjcxxSources()) {
createProjectPart(cat.objcxxSources(), createProjectPart(cat.objcxxSources(),
cat.partName(QCoreApplication::translate("CppTools", "Obj-C++11")), cat.partName(QCoreApplication::translate("CppTools", "Obj-C++11")),
ProjectPart::C11, ProjectPart::CXX11,
ProjectPart::CXX11); ProjectPart::ObjectiveCExtensions);
// TODO: there is no Objective-C++... // TODO: there is no Objective-C++...
languages += ProjectExplorer::Constants::LANG_CXX; languages += ProjectExplorer::Constants::LANG_CXX;
} }
@@ -422,18 +419,20 @@ QList<Core::Id> ProjectPartBuilder::createProjectPartsForFiles(const QStringList
void ProjectPartBuilder::createProjectPart(const QStringList &theSources, void ProjectPartBuilder::createProjectPart(const QStringList &theSources,
const QString &partName, const QString &partName,
ProjectPart::CVersion cVersion, ProjectPart::LanguageVersion languageVersion,
ProjectPart::CXXVersion cxxVersion) ProjectPart::LanguageExtensions languageExtensions)
{ {
CppTools::ProjectPart::Ptr part(m_templatePart->copy()); CppTools::ProjectPart::Ptr part(m_templatePart->copy());
part->displayName = partName; part->displayName = partName;
Kit *k = part->project->activeTarget()->kit(); Kit *k = part->project->activeTarget()->kit();
if (ToolChain *tc = ToolChainKitInformation::toolChain(k)) if (ToolChain *tc = ToolChainKitInformation::toolChain(k))
part->evaluateToolchain(tc, m_cFlags, m_cxxFlags, SysRootKitInformation::sysRoot(k)); part->evaluateToolchain(tc,
languageVersion >= ProjectPart::CXX98 ? m_cxxFlags
: m_cFlags,
SysRootKitInformation::sysRoot(k));
part->cVersion = cVersion; part->languageExtensions |= languageExtensions;
part->cxxVersion = cxxVersion;
CppTools::ProjectFileAdder adder(part->files); CppTools::ProjectFileAdder adder(part->files);
foreach (const QString &file, theSources) foreach (const QString &file, theSources)

42
src/plugins/cpptools/cppprojects.h
View File

@@ -45,27 +45,29 @@ namespace CppTools {
class CPPTOOLS_EXPORT ProjectPart class CPPTOOLS_EXPORT ProjectPart
{ {
public: // Types public: // Types
enum CVersion { enum LanguageVersion {
C89, C89,
C99, C99,
C11 C11,
};
enum CXXVersion {
CXX98, CXX98,
CXX11 CXX03,
CXX11,
CXX14,
CXX17
}; };
enum CXXExtension { enum LanguageExtension {
NoExtensions = 0x0, NoExtensions = 0,
GnuExtensions = 0x1, GnuExtensions = 1 << 0,
MicrosoftExtensions = 0x2, MicrosoftExtensions = 1 << 1,
BorlandExtensions = 0x4, BorlandExtensions = 1 << 2,
OpenMPExtensions = 0x8, OpenMPExtensions = 1 << 3,
ObjectiveCExtensions = 1 << 4,
AllExtensions = GnuExtensions | MicrosoftExtensions | BorlandExtensions | OpenMPExtensions AllExtensions = GnuExtensions | MicrosoftExtensions | BorlandExtensions | OpenMPExtensions
| ObjectiveCExtensions
}; };
Q_DECLARE_FLAGS(CXXExtensions, CXXExtension) Q_DECLARE_FLAGS(LanguageExtensions, LanguageExtension)
enum QtVersion { enum QtVersion {
UnknownQt = -1, UnknownQt = -1,
@@ -101,8 +103,7 @@ public: // methods
ProjectPart(); ProjectPart();
void evaluateToolchain(const ProjectExplorer::ToolChain *tc, void evaluateToolchain(const ProjectExplorer::ToolChain *tc,
const QStringList &cxxflags, const QStringList &commandLineFlags,
const QStringList &cflags,
const Utils::FileName &sysRoot); const Utils::FileName &sysRoot);
Ptr copy() const; Ptr copy() const;
@@ -121,12 +122,10 @@ public: // fields
QByteArray toolchainDefines; QByteArray toolchainDefines;
QList<HeaderPath> headerPaths; QList<HeaderPath> headerPaths;
QStringList precompiledHeaders; QStringList precompiledHeaders;
CVersion cVersion; LanguageVersion languageVersion;
CXXVersion cxxVersion; LanguageExtensions languageExtensions;
CXXExtensions cxxExtensions;
QtVersion qtVersion; QtVersion qtVersion;
ProjectExplorer::ToolChain::WarningFlags cWarningFlags; ProjectExplorer::ToolChain::WarningFlags warningFlags;
ProjectExplorer::ToolChain::WarningFlags cxxWarningFlags;
}; };
inline uint qHash(const ProjectPart::HeaderPath &key, uint seed = 0) inline uint qHash(const ProjectPart::HeaderPath &key, uint seed = 0)
@@ -182,7 +181,8 @@ public:
private: private:
void createProjectPart(const QStringList &theSources, const QString &partName, void createProjectPart(const QStringList &theSources, const QString &partName,
ProjectPart::CVersion cVersion, ProjectPart::CXXVersion cxxVersion); ProjectPart::LanguageVersion languageVersion,
ProjectPart::LanguageExtensions languageExtensions);
private: private:
ProjectPart::Ptr m_templatePart; ProjectPart::Ptr m_templatePart;

8
src/plugins/projectexplorer/gcctoolchain.cpp
View File

@@ -448,9 +448,15 @@ ToolChain::CompilerFlags GccToolChain::compilerFlags(const QStringList &cxxflags
} else if (std == "gnu++98" || std == "gnu++03") { } else if (std == "gnu++98" || std == "gnu++03") {
flags &= ~StandardCxx11; flags &= ~StandardCxx11;
flags |= GnuExtensions; flags |= GnuExtensions;
} else if (std == "c++0x" || std == "c++11" || std== "c++1y") { } else if (std == "c++0x" || std == "c++11") {
flags |= StandardCxx11; flags |= StandardCxx11;
flags &= ~GnuExtensions; flags &= ~GnuExtensions;
} else if (std == "c++14" || std == "c++1y") {
flags |= StandardCxx14;
flags &= ~GnuExtensions;
} else if (std == "c++17" || std == "c++1z") {
flags |= StandardCxx17;
flags &= ~GnuExtensions;
} else if (std == "gnu++0x" || std == "gnu++11" || std== "gnu++1y") { } else if (std == "gnu++0x" || std == "gnu++11" || std== "gnu++1y") {
flags |= CompilerFlags(StandardCxx11 | GnuExtensions); flags |= CompilerFlags(StandardCxx11 | GnuExtensions);
} else if (std == "c89" || std == "c90" } else if (std == "c89" || std == "c90"

5
src/plugins/projectexplorer/toolchain.h
View File

@@ -97,7 +97,10 @@ public:
GnuExtensions = 0x8, GnuExtensions = 0x8,
MicrosoftExtensions = 0x10, MicrosoftExtensions = 0x10,
BorlandExtensions = 0x20, BorlandExtensions = 0x20,
OpenMP = 0x40 OpenMP = 0x40,
ObjectiveC = 0x80,
StandardCxx14 = 0x100,
StandardCxx17 = 0x200
}; };
Q_DECLARE_FLAGS(CompilerFlags, CompilerFlag) Q_DECLARE_FLAGS(CompilerFlags, CompilerFlag)

2
src/plugins/qmakeprojectmanager/qmakeproject.cpp
View File

@@ -579,7 +579,6 @@ void QmakeProject::updateCppCodeModel()
ProjectFile::CXXSource)); ProjectFile::CXXSource));
const QStringList cxxflags = pro->variableValue(CppFlagsVar); const QStringList cxxflags = pro->variableValue(CppFlagsVar);
cppPart->evaluateToolchain(ToolChainKitInformation::toolChain(k), cppPart->evaluateToolchain(ToolChainKitInformation::toolChain(k),
cxxflags,
cxxflags, cxxflags,
SysRootKitInformation::sysRoot(k)); SysRootKitInformation::sysRoot(k));
@@ -604,7 +603,6 @@ void QmakeProject::updateCppCodeModel()
const QStringList cxxflags = pro->variableValue(CppFlagsVar); const QStringList cxxflags = pro->variableValue(CppFlagsVar);
objcppPart->evaluateToolchain(ToolChainKitInformation::toolChain(k), objcppPart->evaluateToolchain(ToolChainKitInformation::toolChain(k),
cxxflags,
cxxflags, cxxflags,
SysRootKitInformation::sysRoot(k)); SysRootKitInformation::sysRoot(k));