diff options
Diffstat (limited to 'src/plugins/cpptools/compileroptionsbuilder.cpp')
| -rw-r--r-- | src/plugins/cpptools/compileroptionsbuilder.cpp | 513 |
1 files changed, 209 insertions, 304 deletions
diff --git a/src/plugins/cpptools/compileroptionsbuilder.cpp b/src/plugins/cpptools/compileroptionsbuilder.cpp index b8475eb3ed..fae2e29fb5 100644 --- a/src/plugins/cpptools/compileroptionsbuilder.cpp +++ b/src/plugins/cpptools/compileroptionsbuilder.cpp @@ -26,12 +26,15 @@ #include "compileroptionsbuilder.h" #include "cppmodelmanager.h" +#include "headerpathfilter.h" #include <coreplugin/icore.h> -#include <coreplugin/vcsmanager.h> -#include <projectexplorer/projectexplorerconstants.h> +#include <projectexplorer/headerpath.h> +#include <projectexplorer/language.h> #include <projectexplorer/project.h> +#include <projectexplorer/projectexplorerconstants.h> +#include <projectexplorer/projectmacro.h> #include <utils/fileutils.h> #include <utils/qtcassert.h> @@ -41,22 +44,53 @@ namespace CppTools { +static const char defineOption[] = "-D"; +static const char undefineOption[] = "-U"; + +static const char includeUserPathOption[] = "-I"; +static const char includeSystemPathOption[] = "-isystem"; + +static const char includeFileOption[] = "-include"; + +static QByteArray macroOption(const ProjectExplorer::Macro ¯o) +{ + switch (macro.type) { + case ProjectExplorer::MacroType::Define: return defineOption; + case ProjectExplorer::MacroType::Undefine: return undefineOption; + default: return QByteArray(); + } +} + +static QByteArray toDefineOption(const ProjectExplorer::Macro ¯o) +{ + return macro.toKeyValue(macroOption(macro)); +} + +static QString defineDirectiveToDefineOption(const ProjectExplorer::Macro ¯o) +{ + const QByteArray option = toDefineOption(macro); + return QString::fromUtf8(option); +} + CompilerOptionsBuilder::CompilerOptionsBuilder(const ProjectPart &projectPart, UseSystemHeader useSystemHeader, - SkipBuiltIn skipBuiltInHeaderPathsAndDefines, - SkipLanguageDefines skipLanguageDefines, - QString clangVersion, - QString clangResourceDirectory) + UseToolchainMacros useToolchainMacros, + UseTweakedHeaderPaths useTweakedHeaderPaths, + UseLanguageDefines useLanguageDefines, + const QString &clangVersion, + const QString &clangResourceDirectory) : m_projectPart(projectPart) + , m_useSystemHeader(useSystemHeader) + , m_useToolchainMacros(useToolchainMacros) + , m_useTweakedHeaderPaths(useTweakedHeaderPaths) + , m_useLanguageDefines(useLanguageDefines) , m_clangVersion(clangVersion) , m_clangResourceDirectory(clangResourceDirectory) - , m_useSystemHeader(useSystemHeader) - , m_skipBuiltInHeaderPathsAndDefines(skipBuiltInHeaderPathsAndDefines) - , m_skipLanguageDefines(skipLanguageDefines) { } -QStringList CompilerOptionsBuilder::build(CppTools::ProjectFile::Kind fileKind, PchUsage pchUsage) +QStringList CompilerOptionsBuilder::build(ProjectFile::Kind fileKind, + UsePrecompiledHeaders usePrecompiledHeaders) { m_options.clear(); @@ -76,18 +110,16 @@ QStringList CompilerOptionsBuilder::build(CppTools::ProjectFile::Kind fileKind, addTargetTriple(); addExtraCodeModelFlags(); - updateLanguageOption(fileKind); - addOptionsForLanguage(/*checkForBorlandExtensions*/ true); - enableExceptions(); + updateFileLanguage(fileKind); + addLanguageVersionAndExtensions(); addToolchainAndProjectMacros(); undefineClangVersionMacrosForMsvc(); undefineCppLanguageFeatureMacrosForMsvc2015(); addDefineFunctionMacrosMsvc(); - addBoostWorkaroundMacros(); addToolchainFlags(); - addPrecompiledHeaderOptions(pchUsage); + addPrecompiledHeaderOptions(usePrecompiledHeaders); addHeaderPathOptions(); addProjectConfigFileInclude(); @@ -102,7 +134,7 @@ QStringList CompilerOptionsBuilder::build(CppTools::ProjectFile::Kind fileKind, static QStringList createLanguageOptionGcc(ProjectFile::Kind fileKind, bool objcExt) { - QStringList opts; + QStringList options; switch (fileKind) { case ProjectFile::Unclassified: @@ -110,80 +142,67 @@ static QStringList createLanguageOptionGcc(ProjectFile::Kind fileKind, bool objc break; case ProjectFile::CHeader: if (objcExt) - opts += QLatin1String("objective-c-header"); + options += "objective-c-header"; else - opts += QLatin1String("c-header"); + options += "c-header"; break; - case ProjectFile::CXXHeader: default: if (!objcExt) { - opts += QLatin1String("c++-header"); + options += "c++-header"; break; } Q_FALLTHROUGH(); case ProjectFile::ObjCHeader: case ProjectFile::ObjCXXHeader: - opts += QLatin1String("objective-c++-header"); + options += "objective-c++-header"; break; case ProjectFile::CSource: if (!objcExt) { - opts += QLatin1String("c"); + options += "c"; break; } Q_FALLTHROUGH(); case ProjectFile::ObjCSource: - opts += QLatin1String("objective-c"); + options += "objective-c"; break; - case ProjectFile::CXXSource: if (!objcExt) { - opts += QLatin1String("c++"); + options += "c++"; break; } Q_FALLTHROUGH(); case ProjectFile::ObjCXXSource: - opts += QLatin1String("objective-c++"); + options += "objective-c++"; break; - case ProjectFile::OpenCLSource: - opts += QLatin1String("cl"); + options += "cl"; break; case ProjectFile::CudaSource: - opts += QLatin1String("cuda"); + options += "cuda"; break; } - if (!opts.isEmpty()) - opts.prepend(QLatin1String("-x")); - - return opts; -} - -QStringList CompilerOptionsBuilder::options() const -{ - return m_options; -} + if (!options.isEmpty()) + options.prepend("-x"); -void CompilerOptionsBuilder::add(const QString &option) -{ - m_options.append(option); + return options; } void CompilerOptionsBuilder::addWordWidth() { const QString argument = m_projectPart.toolChainWordWidth == ProjectPart::WordWidth64Bit - ? QLatin1String("-m64") - : QLatin1String("-m32"); + ? QLatin1String("-m64") + : QLatin1String("-m32"); add(argument); } void CompilerOptionsBuilder::addTargetTriple() { if (!m_projectPart.toolChainTargetTriple.isEmpty()) { - m_options.append(QLatin1String("-target")); - m_options.append(m_projectPart.toolChainTargetTriple); + add("-target"); + add(m_projectPart.toolChainTargetTriple); } } @@ -195,13 +214,6 @@ void CompilerOptionsBuilder::addExtraCodeModelFlags() m_options.append(m_projectPart.extraCodeModelFlags); } -void CompilerOptionsBuilder::enableExceptions() -{ - if (m_projectPart.languageVersion > ProjectExplorer::LanguageVersion::LatestC) - add(QLatin1String("-fcxx-exceptions")); - add(QLatin1String("-fexceptions")); -} - static QString creatorResourcePath() { #ifndef UNIT_TESTS @@ -211,58 +223,9 @@ static QString creatorResourcePath() #endif } -static QString clangIncludeDirectory(const QString &clangVersion, - const QString &clangResourceDirectory) -{ -#ifndef UNIT_TESTS - return Core::ICore::clangIncludeDirectory(clangVersion, clangResourceDirectory); -#else - return QDir::toNativeSeparators(QString::fromUtf8(CLANG_RESOURCE_DIR "")); -#endif -} - -static QStringList insertResourceDirectory(const QStringList &options, - const QString &resourceDir, - bool isMacOs = false) -{ - // include/c++, include/g++, libc++\include and libc++abi\include - static const QString cppIncludes = R"((.*[\/\\]include[\/\\].*(g\+\+|c\+\+).*))" - R"(|(.*libc\+\+[\/\\]include))" - R"(|(.*libc\+\+abi[\/\\]include))"; - - QStringList optionsBeforeResourceDirectory; - QStringList optionsAfterResourceDirectory; - QRegularExpression includeRegExp; - if (!isMacOs) { - includeRegExp = QRegularExpression("\\A(" + cppIncludes + ")\\z"); - } else { - // The same as includeRegExp but also matches /usr/local/include - includeRegExp = QRegularExpression( - "\\A(" + cppIncludes + R"(|([\/\\]usr[\/\\]local[\/\\]include))" + ")\\z"); - } - - for (const QString &option : options) { - if (option == "-isystem") - continue; - - if (includeRegExp.match(option).hasMatch()) { - optionsBeforeResourceDirectory.push_back("-isystem"); - optionsBeforeResourceDirectory.push_back(option); - } else { - optionsAfterResourceDirectory.push_back("-isystem"); - optionsAfterResourceDirectory.push_back(option); - } - } - - optionsBeforeResourceDirectory.push_back("-isystem"); - optionsBeforeResourceDirectory.push_back(resourceDir); - - return optionsBeforeResourceDirectory + optionsAfterResourceDirectory; -} - void CompilerOptionsBuilder::insertWrappedQtHeaders() { - if (m_skipBuiltInHeaderPathsAndDefines == SkipBuiltIn::Yes) + if (m_useTweakedHeaderPaths == UseTweakedHeaderPaths::No) return; QStringList wrappedQtHeaders; @@ -277,110 +240,83 @@ void CompilerOptionsBuilder::insertWrappedQtHeaders() void CompilerOptionsBuilder::addHeaderPathOptions() { - using ProjectExplorer::HeaderPathType; + HeaderPathFilter filter{m_projectPart, + m_useTweakedHeaderPaths, + m_clangVersion, + m_clangResourceDirectory}; - QStringList includes; - QStringList systemIncludes; - QStringList builtInIncludes; - - for (const ProjectExplorer::HeaderPath &headerPath : qAsConst(m_projectPart.headerPaths)) { - if (headerPath.path.isEmpty()) - continue; + filter.process(); - if (excludeHeaderPath(headerPath.path)) - continue; + using ProjectExplorer::HeaderPath; + using ProjectExplorer::HeaderPathType; - switch (headerPath.type) { - case HeaderPathType::Framework: - includes.append("-F"); - includes.append(QDir::toNativeSeparators(headerPath.path)); - break; - default: // This shouldn't happen, but let's be nice..: - // intentional fall-through: - case HeaderPathType::User: - includes.append(includeDirOptionForPath(headerPath.path)); - includes.append(QDir::toNativeSeparators(headerPath.path)); - break; - case HeaderPathType::BuiltIn: - builtInIncludes.append("-isystem"); - builtInIncludes.append(QDir::toNativeSeparators(headerPath.path)); - break; - case HeaderPathType::System: - systemIncludes.append(m_useSystemHeader == UseSystemHeader::No - ? QLatin1String("-I") - : QLatin1String("-isystem")); - systemIncludes.append(QDir::toNativeSeparators(headerPath.path)); - break; + if (m_useTweakedHeaderPaths == UseTweakedHeaderPaths::Yes) { + // Exclude all built-in includes except Clang resource directory. + m_options.prepend("-nostdlibinc"); + if (!m_clangVersion.isEmpty()) { + // Exclude all built-in includes and Clang resource directory. + m_options.prepend("-nostdinc"); } } - m_options.append(includes); - m_options.append(systemIncludes); - - if (m_skipBuiltInHeaderPathsAndDefines == SkipBuiltIn::Yes) - return; - - // Exclude all built-in includes except Clang resource directory. - m_options.prepend("-nostdlibinc"); - - if (!m_clangVersion.isEmpty()) { - // Exclude all built-in includes and Clang resource directory. - m_options.prepend("-nostdinc"); - const QString clangIncludePath - = clangIncludeDirectory(m_clangVersion, m_clangResourceDirectory); + for (const HeaderPath &headerPath : filter.userHeaderPaths) { + m_options.push_back(includeDirOptionForPath(headerPath.path)); + m_options.push_back(QDir::toNativeSeparators(headerPath.path)); + } - builtInIncludes = insertResourceDirectory(builtInIncludes, - clangIncludePath, - m_projectPart.toolChainTargetTriple.contains( - "darwin")); + for (const HeaderPath &headerPath : filter.systemHeaderPaths) { + m_options.push_back(includeDirOptionForSystemPath(headerPath.type)); + m_options.push_back(QDir::toNativeSeparators(headerPath.path)); } - m_options.append(builtInIncludes); + for (const HeaderPath &headerPath : filter.builtInHeaderPaths) { + m_options.push_back(includeSystemPathOption); + m_options.push_back(QDir::toNativeSeparators(headerPath.path)); + } } -void CompilerOptionsBuilder::addPrecompiledHeaderOptions(PchUsage pchUsage) +void CompilerOptionsBuilder::addPrecompiledHeaderOptions(UsePrecompiledHeaders usePrecompiledHeaders) { - if (pchUsage == PchUsage::None) + if (usePrecompiledHeaders == UsePrecompiledHeaders::No) return; - QStringList result; + QStringList options; - const QString includeOptionString = includeOption(); - foreach (const QString &pchFile, m_projectPart.precompiledHeaders) { + for (const QString &pchFile : m_projectPart.precompiledHeaders) { if (QFile::exists(pchFile)) { - result += includeOptionString; - result += QDir::toNativeSeparators(pchFile); + options += includeFileOption; + options += QDir::toNativeSeparators(pchFile); } } - m_options.append(result); + m_options.append(options); } void CompilerOptionsBuilder::addToolchainAndProjectMacros() { - if (m_skipBuiltInHeaderPathsAndDefines == SkipBuiltIn::No) + if (m_useToolchainMacros == UseToolchainMacros::Yes) addMacros(m_projectPart.toolChainMacros); addMacros(m_projectPart.projectMacros); } void CompilerOptionsBuilder::addMacros(const ProjectExplorer::Macros ¯os) { - QStringList result; + QStringList options; for (const ProjectExplorer::Macro ¯o : macros) { if (excludeDefineDirective(macro)) continue; const QString defineOption = defineDirectiveToDefineOption(macro); - if (!result.contains(defineOption)) - result.append(defineOption); + if (!options.contains(defineOption)) + options.append(defineOption); } - m_options.append(result); + m_options.append(options); } -void CompilerOptionsBuilder::updateLanguageOption(ProjectFile::Kind fileKind) +void CompilerOptionsBuilder::updateFileLanguage(ProjectFile::Kind fileKind) { const bool objcExt = m_projectPart.languageExtensions & ProjectExplorer::LanguageExtension::ObjectiveC; @@ -390,66 +326,65 @@ void CompilerOptionsBuilder::updateLanguageOption(ProjectFile::Kind fileKind) QTC_ASSERT(options.size() == 2, return;); int langOptIndex = m_options.indexOf("-x"); - if (langOptIndex == -1) { + if (langOptIndex == -1) m_options.append(options); - } else { + else m_options[langOptIndex + 1] = options[1]; - } } -void CompilerOptionsBuilder::addOptionsForLanguage(bool checkForBorlandExtensions) +void CompilerOptionsBuilder::addLanguageVersionAndExtensions() { using ProjectExplorer::LanguageExtension; using ProjectExplorer::LanguageVersion; - QStringList opts; + QStringList options; const ProjectExplorer::LanguageExtensions languageExtensions = m_projectPart.languageExtensions; const bool gnuExtensions = languageExtensions & LanguageExtension::Gnu; switch (m_projectPart.languageVersion) { case LanguageVersion::C89: - opts << (gnuExtensions ? QLatin1String("-std=gnu89") : QLatin1String("-std=c89")); + options << (gnuExtensions ? QLatin1String("-std=gnu89") : QLatin1String("-std=c89")); break; case LanguageVersion::C99: - opts << (gnuExtensions ? QLatin1String("-std=gnu99") : QLatin1String("-std=c99")); + options << (gnuExtensions ? QLatin1String("-std=gnu99") : QLatin1String("-std=c99")); break; case LanguageVersion::C11: - opts << (gnuExtensions ? QLatin1String("-std=gnu11") : QLatin1String("-std=c11")); + options << (gnuExtensions ? QLatin1String("-std=gnu11") : QLatin1String("-std=c11")); break; case LanguageVersion::C18: // Clang 6, 7 and current trunk do not accept "gnu18"/"c18", so use the "*17" variants. - opts << (gnuExtensions ? QLatin1String("-std=gnu17") : QLatin1String("-std=c17")); + options << (gnuExtensions ? QLatin1String("-std=gnu17") : QLatin1String("-std=c17")); break; case LanguageVersion::CXX11: - opts << (gnuExtensions ? QLatin1String("-std=gnu++11") : QLatin1String("-std=c++11")); + options << (gnuExtensions ? QLatin1String("-std=gnu++11") : QLatin1String("-std=c++11")); break; case LanguageVersion::CXX98: - opts << (gnuExtensions ? QLatin1String("-std=gnu++98") : QLatin1String("-std=c++98")); + options << (gnuExtensions ? QLatin1String("-std=gnu++98") : QLatin1String("-std=c++98")); break; case LanguageVersion::CXX03: - opts << (gnuExtensions ? QLatin1String("-std=gnu++03") : QLatin1String("-std=c++03")); + options << (gnuExtensions ? QLatin1String("-std=gnu++03") : QLatin1String("-std=c++03")); break; case LanguageVersion::CXX14: - opts << (gnuExtensions ? QLatin1String("-std=gnu++14") : QLatin1String("-std=c++14")); + options << (gnuExtensions ? QLatin1String("-std=gnu++14") : QLatin1String("-std=c++14")); break; case LanguageVersion::CXX17: - opts << (gnuExtensions ? QLatin1String("-std=gnu++17") : QLatin1String("-std=c++17")); + options << (gnuExtensions ? QLatin1String("-std=gnu++17") : QLatin1String("-std=c++17")); break; case LanguageVersion::CXX2a: - opts << (gnuExtensions ? QLatin1String("-std=gnu++2a") : QLatin1String("-std=c++2a")); + options << (gnuExtensions ? QLatin1String("-std=gnu++2a") : QLatin1String("-std=c++2a")); break; } if (languageExtensions & LanguageExtension::Microsoft) - opts << QLatin1String("-fms-extensions"); + options << "-fms-extensions"; if (languageExtensions & LanguageExtension::OpenMP) - opts << QLatin1String("-fopenmp"); + options << "-fopenmp"; - if (checkForBorlandExtensions && (languageExtensions & LanguageExtension::Borland)) - opts << QLatin1String("-fborland-extensions"); + if (languageExtensions & LanguageExtension::Borland) + options << "-fborland-extensions"; - m_options.append(opts); + m_options.append(options); } static QByteArray toMsCompatibilityVersionFormat(const QByteArray &mscFullVer) @@ -481,7 +416,6 @@ void CompilerOptionsBuilder::addMsvcCompatibilityVersion() if (m_projectPart.toolchainType == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID || m_projectPart.toolchainType == ProjectExplorer::Constants::CLANG_CL_TOOLCHAIN_TYPEID) { const QByteArray msvcVer = msvcVersion(); - if (!msvcVer.isEmpty()) add(QLatin1String("-fms-compatibility-version=") + msvcVer); } @@ -494,54 +428,54 @@ static QStringList languageFeatureMacros() // * Use latest -fms-compatibility-version and -std possible. // * Compatibility version 19 vs 1910 did not matter. // $ clang++ -fms-compatibility-version=19 -std=c++1z -dM -E D:\empty.cpp | grep __cpp_ - static QStringList macros{ - QLatin1String("__cpp_aggregate_bases"), - QLatin1String("__cpp_aggregate_nsdmi"), - QLatin1String("__cpp_alias_templates"), - QLatin1String("__cpp_aligned_new"), - QLatin1String("__cpp_attributes"), - QLatin1String("__cpp_binary_literals"), - QLatin1String("__cpp_capture_star_this"), - QLatin1String("__cpp_constexpr"), - QLatin1String("__cpp_decltype"), - QLatin1String("__cpp_decltype_auto"), - QLatin1String("__cpp_deduction_guides"), - QLatin1String("__cpp_delegating_constructors"), - QLatin1String("__cpp_digit_separators"), - QLatin1String("__cpp_enumerator_attributes"), - QLatin1String("__cpp_exceptions"), - QLatin1String("__cpp_fold_expressions"), - QLatin1String("__cpp_generic_lambdas"), - QLatin1String("__cpp_guaranteed_copy_elision"), - QLatin1String("__cpp_hex_float"), - QLatin1String("__cpp_if_constexpr"), - QLatin1String("__cpp_inheriting_constructors"), - QLatin1String("__cpp_init_captures"), - QLatin1String("__cpp_initializer_lists"), - QLatin1String("__cpp_inline_variables"), - QLatin1String("__cpp_lambdas"), - QLatin1String("__cpp_namespace_attributes"), - QLatin1String("__cpp_nested_namespace_definitions"), - QLatin1String("__cpp_noexcept_function_type"), - QLatin1String("__cpp_nontype_template_args"), - QLatin1String("__cpp_nontype_template_parameter_auto"), - QLatin1String("__cpp_nsdmi"), - QLatin1String("__cpp_range_based_for"), - QLatin1String("__cpp_raw_strings"), - QLatin1String("__cpp_ref_qualifiers"), - QLatin1String("__cpp_return_type_deduction"), - QLatin1String("__cpp_rtti"), - QLatin1String("__cpp_rvalue_references"), - QLatin1String("__cpp_static_assert"), - QLatin1String("__cpp_structured_bindings"), - QLatin1String("__cpp_template_auto"), - QLatin1String("__cpp_threadsafe_static_init"), - QLatin1String("__cpp_unicode_characters"), - QLatin1String("__cpp_unicode_literals"), - QLatin1String("__cpp_user_defined_literals"), - QLatin1String("__cpp_variable_templates"), - QLatin1String("__cpp_variadic_templates"), - QLatin1String("__cpp_variadic_using"), + static const QStringList macros{ + "__cpp_aggregate_bases", + "__cpp_aggregate_nsdmi", + "__cpp_alias_templates", + "__cpp_aligned_new", + "__cpp_attributes", + "__cpp_binary_literals", + "__cpp_capture_star_this", + "__cpp_constexpr", + "__cpp_decltype", + "__cpp_decltype_auto", + "__cpp_deduction_guides", + "__cpp_delegating_constructors", + "__cpp_digit_separators", + "__cpp_enumerator_attributes", + "__cpp_exceptions", + "__cpp_fold_expressions", + "__cpp_generic_lambdas", + "__cpp_guaranteed_copy_elision", + "__cpp_hex_float", + "__cpp_if_constexpr", + "__cpp_inheriting_constructors", + "__cpp_init_captures", + "__cpp_initializer_lists", + "__cpp_inline_variables", + "__cpp_lambdas", + "__cpp_namespace_attributes", + "__cpp_nested_namespace_definitions", + "__cpp_noexcept_function_type", + "__cpp_nontype_template_args", + "__cpp_nontype_template_parameter_auto", + "__cpp_nsdmi", + "__cpp_range_based_for", + "__cpp_raw_strings", + "__cpp_ref_qualifiers", + "__cpp_return_type_deduction", + "__cpp_rtti", + "__cpp_rvalue_references", + "__cpp_static_assert", + "__cpp_structured_bindings", + "__cpp_template_auto", + "__cpp_threadsafe_static_init", + "__cpp_unicode_characters", + "__cpp_unicode_literals", + "__cpp_user_defined_literals", + "__cpp_variable_templates", + "__cpp_variadic_templates", + "__cpp_variadic_using", }; return macros; @@ -553,22 +487,18 @@ void CompilerOptionsBuilder::undefineCppLanguageFeatureMacrosForMsvc2015() && m_projectPart.isMsvc2015Toolchain) { // Undefine the language feature macros that are pre-defined in clang-cl, // but not in MSVC's cl.exe. - foreach (const QString ¯oName, languageFeatureMacros()) - m_options.append(undefineOption() + macroName); + const QStringList macroNames = languageFeatureMacros(); + for (const QString ¯oName : macroNames) + add(undefineOption + macroName); } } void CompilerOptionsBuilder::addDefineFunctionMacrosMsvc() { - if (m_projectPart.toolchainType == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) - addMacros({{"__FUNCSIG__", "\"\""}, {"__FUNCTION__", "\"\""}, {"__FUNCDNAME__", "\"\""}}); -} - -void CompilerOptionsBuilder::addBoostWorkaroundMacros() -{ - if (m_projectPart.toolchainType != ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID - && m_projectPart.toolchainType != ProjectExplorer::Constants::CLANG_CL_TOOLCHAIN_TYPEID) { - addMacros({{"BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING", "(39, 1, true, \"T = \")"}}); + if (m_projectPart.toolchainType == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) { + addMacros({{"__FUNCSIG__", "\"\""}, + {"__FUNCTION__", "\"\""}, + {"__FUNCDNAME__", "\"\""}}); } } @@ -576,46 +506,10 @@ QString CompilerOptionsBuilder::includeDirOptionForPath(const QString &path) con { if (m_useSystemHeader == UseSystemHeader::No || path.startsWith(m_projectPart.project->rootProjectDirectory().toString())) { - return QString("-I"); - } else { - return QString("-isystem"); - } -} - -QByteArray CompilerOptionsBuilder::macroOption(const ProjectExplorer::Macro ¯o) const -{ - switch (macro.type) { - case ProjectExplorer::MacroType::Define: return defineOption().toUtf8(); - case ProjectExplorer::MacroType::Undefine: return undefineOption().toUtf8(); - default: return QByteArray(); + return QLatin1String(includeUserPathOption); } -} - -QByteArray CompilerOptionsBuilder::toDefineOption(const ProjectExplorer::Macro ¯o) const -{ - return macro.toKeyValue(macroOption(macro)); -} -QString CompilerOptionsBuilder::defineDirectiveToDefineOption(const ProjectExplorer::Macro ¯o) const -{ - const QByteArray option = toDefineOption(macro); - - return QString::fromUtf8(option); -} - -QString CompilerOptionsBuilder::defineOption() const -{ - return QLatin1String("-D"); -} - -QString CompilerOptionsBuilder::undefineOption() const -{ - return QLatin1String("-U"); -} - -QString CompilerOptionsBuilder::includeOption() const -{ - return QLatin1String("-include"); + return QLatin1String(includeSystemPathOption); } bool CompilerOptionsBuilder::excludeDefineDirective(const ProjectExplorer::Macro ¯o) const @@ -628,7 +522,7 @@ bool CompilerOptionsBuilder::excludeDefineDirective(const ProjectExplorer::Macro "_MSVC_LANG", "_MSC_FULL_VER", "_MSC_VER"}; - if (m_skipLanguageDefines == SkipLanguageDefines::Yes + if (m_useLanguageDefines == UseLanguageDefines::No && std::find(languageDefines.begin(), languageDefines.end(), macro.key) != languageDefines.end()) { @@ -660,24 +554,13 @@ bool CompilerOptionsBuilder::excludeDefineDirective(const ProjectExplorer::Macro return false; } -bool CompilerOptionsBuilder::excludeHeaderPath(const QString &headerPath) const -{ - // Always exclude clang system includes (including intrinsics) which do not come with libclang - // that Qt Creator uses for code model. - // For example GCC on macOS uses system clang include path which makes clang code model - // include incorrect system headers. - static QRegularExpression clangIncludeDir( - QLatin1String("\\A.*[\\/\\\\]lib\\d*[\\/\\\\]clang[\\/\\\\]\\d+\\.\\d+(\\.\\d+)?[\\/\\\\]include\\z")); - return clangIncludeDir.match(headerPath).hasMatch(); -} - -void CompilerOptionsBuilder::addWrappedQtHeadersIncludePath(QStringList &list) +void CompilerOptionsBuilder::addWrappedQtHeadersIncludePath(QStringList &list) const { static const QString resourcePath = creatorResourcePath(); static QString wrappedQtHeadersPath = resourcePath + "/cplusplus/wrappedQtHeaders"; QTC_ASSERT(QDir(wrappedQtHeadersPath).exists(), return;); - if (m_projectPart.qtVersion != CppTools::ProjectPart::NoQt) { + if (m_projectPart.qtVersion != ProjectPart::NoQt) { const QString wrappedQtCoreHeaderPath = wrappedQtHeadersPath + "/QtCore"; list.append(includeDirOptionForPath(wrappedQtHeadersPath)); list.append(QDir::toNativeSeparators(wrappedQtHeadersPath)); @@ -686,12 +569,23 @@ void CompilerOptionsBuilder::addWrappedQtHeadersIncludePath(QStringList &list) } } +QString CompilerOptionsBuilder::includeDirOptionForSystemPath(ProjectExplorer::HeaderPathType type) const +{ + if (type == ProjectExplorer::HeaderPathType::Framework) + return QString("-F"); + + if (m_useSystemHeader == UseSystemHeader::Yes) + return QString(includeSystemPathOption); + + return QString(includeUserPathOption); +} + void CompilerOptionsBuilder::addToolchainFlags() { // In case of MSVC we need builtin clang defines to correctly handle clang includes if (m_projectPart.toolchainType != ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID && m_projectPart.toolchainType != ProjectExplorer::Constants::CLANG_CL_TOOLCHAIN_TYPEID) { - if (m_skipBuiltInHeaderPathsAndDefines == SkipBuiltIn::No) + if (m_useToolchainMacros == UseToolchainMacros::Yes) add("-undef"); else add("-fPIC"); @@ -701,7 +595,7 @@ void CompilerOptionsBuilder::addToolchainFlags() void CompilerOptionsBuilder::addProjectConfigFileInclude() { if (!m_projectPart.projectConfigFile.isEmpty()) { - add("-include"); + add(includeFileOption); add(QDir::toNativeSeparators(m_projectPart.projectConfigFile)); } } @@ -713,7 +607,7 @@ void CompilerOptionsBuilder::undefineClangVersionMacrosForMsvc() if (msvcVer.toFloat() < 14.f) { // Original fix was only for msvc 2013 (version 12.0) // Undefying them for newer versions is not necessary and breaks boost. - static QStringList macroNames { + static const QStringList macroNames { "__clang__", "__clang_major__", "__clang_minor__", @@ -721,10 +615,21 @@ void CompilerOptionsBuilder::undefineClangVersionMacrosForMsvc() "__clang_version__" }; - foreach (const QString ¯oName, macroNames) - add(undefineOption() + macroName); + for (const QString ¯oName : macroNames) + add(undefineOption + macroName); } } } +UseToolchainMacros CompilerOptionsBuilder::useToolChainMacros() +{ + return qEnvironmentVariableIntValue("QTC_CLANG_USE_TOOLCHAIN_MACROS") ? UseToolchainMacros::Yes + : UseToolchainMacros::No; +} + +void CompilerOptionsBuilder::reset() +{ + m_options.clear(); +} + } // namespace CppTools |