maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/lib/Lex/PPDirectives.cpp

2976 lines
113 KiB
C++
Raw Normal View History

split macro expansion support out of Preprocessor.cpp into PPMacroExpansion.cpp Rename Directives.cpp -> PPDirectives.cpp since it implements part of the Preprocessor class. llvm-svn: 48078
2008-03-09 11:13:06 +08:00
//===--- PPDirectives.cpp - Directive Handling for Preprocessor -----------===//
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
//
Update the file headers across all of the LLVM projects in the monorepo to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
2019-01-19 16:50:56 +08:00
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
//
//===----------------------------------------------------------------------===//
Documentation cleanup: * Add \brief summaries; * Escape # characters in Doxygen comments; * Add \code...\endcode markup for code examples; * Add \verbatim...\endverbatim markup for grammar productions. llvm-svn: 158976
2012-06-22 13:46:07 +08:00
///
/// \file
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Implements # directive processing for the Preprocessor.
Documentation cleanup: * Add \brief summaries; * Escape # characters in Doxygen comments; * Add \code...\endcode markup for code examples; * Add \verbatim...\endverbatim markup for grammar productions. llvm-svn: 158976
2012-06-22 13:46:07 +08:00
///
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
//===----------------------------------------------------------------------===//
Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes. Differential revision: https://reviews.llvm.org/D24115 llvm-svn: 280870
2016-09-08 05:53:17 +08:00
#include "clang/Basic/CharInfo.h"
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "clang/Basic/FileManager.h"
Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes. Differential revision: https://reviews.llvm.org/D24115 llvm-svn: 280870
2016-09-08 05:53:17 +08:00
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/Module.h"
#include "clang/Basic/SourceLocation.h"
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "clang/Basic/SourceManager.h"
Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes. Differential revision: https://reviews.llvm.org/D24115 llvm-svn: 280870
2016-09-08 05:53:17 +08:00
#include "clang/Basic/TokenKinds.h"
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "clang/Lex/CodeCompletionHandler.h"
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
#include "clang/Lex/HeaderSearch.h"
move library-specific diagnostic headers into library private dirs. Reduce redundant #includes. Patch by Anders Johnsen! llvm-svn: 63271
2009-01-29 13:15:15 +08:00
#include "clang/Lex/LexDiagnostic.h"
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "clang/Lex/LiteralSupport.h"
#include "clang/Lex/MacroInfo.h"
Add an experimental flag -fauto-module-import that automatically turns #include or #import direcctives of framework headers into module imports of the corresponding framework module. llvm-svn: 139860
2011-09-16 06:00:41 +08:00
#include "clang/Lex/ModuleLoader.h"
Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes. Differential revision: https://reviews.llvm.org/D24115 llvm-svn: 280870
2016-09-08 05:53:17 +08:00
#include "clang/Lex/ModuleMap.h"
#include "clang/Lex/PPCallbacks.h"
When we parse a pragma, keep track of how that pragma was originally spelled (#pragma, _Pragma, __pragma). In -E mode, use that information to add appropriate newlines when translating _Pragma and __pragma into #pragma, like GCC does. Fixes <rdar://problem/8412013>. llvm-svn: 113553
2010-09-10 06:45:38 +08:00
#include "clang/Lex/Pragma.h"
[NFC] Header cleanup Summary: Removed unused headers, replaced some headers with forward class declarations Patch by: Eugene <claprix@yandex.ru> Differential Revision: https://reviews.llvm.org/D20100 llvm-svn: 275882
2016-07-19 03:02:11 +08:00
#include "clang/Lex/Preprocessor.h"
[libclang] Introduce a new parsing option 'CXTranslationUnit_SingleFileParse' that puts preprocessor in a mode for parsing a single file only. This is useful for parsing a single file, as a fast/inaccurate 'mode' that can still provide declarations from the file, like the classes and their methods. llvm-svn: 305044
2017-06-09 09:20:48 +08:00
#include "clang/Lex/PreprocessorOptions.h"
Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes. Differential revision: https://reviews.llvm.org/D24115 llvm-svn: 280870
2016-09-08 05:53:17 +08:00
#include "clang/Lex/Token.h"
[NFC] Use RAII to un-poison and then re-poison __VA_ARGS__ - This will also be used for the forthcoming __VA_OPT__ feature approved for C++2a. - recommended by rsmith during his review of the __VA_OPT__ patch (https://reviews.llvm.org/D35782) llvm-svn: 308948
2017-07-25 11:15:36 +08:00
#include "clang/Lex/VariadicMacroSupport.h"
Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes. Differential revision: https://reviews.llvm.org/D24115 llvm-svn: 280870
2016-09-08 05:53:17 +08:00
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h"
Use the name of the file on disk to issue a new diagnostic about non-portable #include and #import paths. Differential Revision: http://reviews.llvm.org/D19843 Corresponding LLVM change: http://reviews.llvm.org/D19842 Re-commit of r272562 after addressing clang-x86-win2008-selfhost failure. llvm-svn: 272584
2016-06-14 04:40:21 +08:00
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringSwitch.h"
Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes. Differential revision: https://reviews.llvm.org/D24115 llvm-svn: 280870
2016-09-08 05:53:17 +08:00
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/AlignOf.h"
Introduce an opt-in warning indicating when the compiler is treating an #include/#import as a module import. llvm-svn: 145500
2011-12-01 02:02:36 +08:00
#include "llvm/Support/ErrorHandling.h"
Use llvm::sys::path::native instead of llvm::sys::fs::normalize_separators. llvm::sys::path::native has a superset of the functionality and this was the only use of llvm::sys::fs::normalize_separators. llvm-svn: 215242
2014-08-09 05:31:04 +08:00
#include "llvm/Support/Path.h"
Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes. Differential revision: https://reviews.llvm.org/D24115 llvm-svn: 280870
2016-09-08 05:53:17 +08:00
#include <algorithm>
#include <cassert>
#include <cstring>
#include <new>
#include <string>
#include <utility>
Fix remaining Clang-tidy readability-redundant-control-flow warnings; other minor fixes. Differential revision: http://reviews.llvm.org/D17218 llvm-svn: 260757
2016-02-13 06:53:10 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
using namespace clang;
//===----------------------------------------------------------------------===//
// Utility Methods for Preprocessor Directive Handling.
//===----------------------------------------------------------------------===//
Remove unused tracking of owning module for MacroInfo objects. llvm-svn: 302966
2017-05-13 07:40:52 +08:00
MacroInfo *Preprocessor::AllocateMacroInfo(SourceLocation L) {
auto *MIChain = new (BP) MacroInfoChain{L, MIChainHead};
Really^2 fix <rdar://problem/8361834>, this time without crashing. Now MICache is a linked list (per the FIXME), where we tradeoff between MacroInfo objects being in MICache and MIChainHead. MacroInfo objects in the MICache chain are already "Destroy()'ed", so they can be reused. When inserting into MICache, we need to remove them from the regular linked list so that they aren't destroyed more than once. llvm-svn: 116869
2010-10-20 06:15:20 +08:00
MIChainHead = MIChain;
Remove unused Prev pointer from MacroInfo chain. Remove pointless MICache: it only ever contained up to 1 object, and was only non-empty when recovering from an error. There's no performance or memory win from maintaining this cache. llvm-svn: 213825
2014-07-24 09:13:23 +08:00
return &MIChain->MI;
Implement #pragma push_macro, patch by Francois Pichet! llvm-svn: 111234
2010-08-17 23:55:45 +08:00
}
[modules] Refactor creation of ModuleMacros and create them when importing from local submodules. llvm-svn: 235669
2015-04-24 07:29:05 +08:00
DefMacroDirective *Preprocessor::AllocateDefMacroDirective(MacroInfo *MI,
SourceLocation Loc) {
[modules] Store a ModuleMacro* on an imported macro directive rather than duplicating the info within it. llvm-svn: 235644
2015-04-24 04:40:50 +08:00
return new (BP) DefMacroDirective(MI, Loc);
[Preprocessor/Modules] Separate the macro directives kinds into their own MacroDirective's subclasses. For each macro directive (define, undefine, visibility) have a separate object that gets chained to the macro directive history. This has several benefits: -No need to mutate a MacroDirective when there is a undefine/visibility directive. Stuff like PPMutationListener become unnecessary. -No need to keep extra source locations for the undef/visibility locations for the define directive object (which is the majority of the directives) -Much easier to hide/unhide a section in the macro directive history. -Easier to track the effects of the directives across different submodules. llvm-svn: 178037
2013-03-27 01:17:01 +08:00
}
UndefMacroDirective *
[modules] Refactor creation of ModuleMacros and create them when importing from local submodules. llvm-svn: 235669
2015-04-24 07:29:05 +08:00
Preprocessor::AllocateUndefMacroDirective(SourceLocation UndefLoc) {
[modules] Store a ModuleMacro* on an imported macro directive rather than duplicating the info within it. llvm-svn: 235644
2015-04-24 04:40:50 +08:00
return new (BP) UndefMacroDirective(UndefLoc);
[Preprocessor/Modules] Separate the macro directives kinds into their own MacroDirective's subclasses. For each macro directive (define, undefine, visibility) have a separate object that gets chained to the macro directive history. This has several benefits: -No need to mutate a MacroDirective when there is a undefine/visibility directive. Stuff like PPMutationListener become unnecessary. -No need to keep extra source locations for the undef/visibility locations for the define directive object (which is the majority of the directives) -Much easier to hide/unhide a section in the macro directive history. -Easier to track the effects of the directives across different submodules. llvm-svn: 178037
2013-03-27 01:17:01 +08:00
}
VisibilityMacroDirective *
Preprocessor::AllocateVisibilityMacroDirective(SourceLocation Loc,
bool isPublic) {
[modules] Substantially improve handling of #undef: * Track override set across module load and save * Track originating module to allow proper re-export of #undef * Make override set properly transitive when it picks up a #undef This fixes nearly all of the remaining macro issues with self-host. llvm-svn: 213922
2014-07-25 12:40:03 +08:00
return new (BP) VisibilityMacroDirective(Loc, isPublic);
Implement #pragma push_macro, patch by Francois Pichet! llvm-svn: 111234
2010-08-17 23:55:45 +08:00
}
Remove random windows line endings that snuck into the middle of this code. llvm-svn: 351633
2019-01-19 14:36:00 +08:00
/// Read and discard all tokens remaining on the current line until
/// the tok::eod token is found.
SourceRange Preprocessor::DiscardUntilEndOfDirective() {
Token Tmp;
SourceRange Res;
LexUnexpandedToken(Tmp);
Res.setBegin(Tmp.getLocation());
while (Tmp.isNot(tok::eod)) {
assert(Tmp.isNot(tok::eof) && "EOF seen while discarding directive tokens");
LexUnexpandedToken(Tmp);
}
Res.setEnd(Tmp.getLocation());
return Res;
}
/// Enumerates possible cases of #define/#undef a reserved identifier.
Fixed warnings on redefine keywords and reserved ids. Repared support for warnings -Wkeyword-macro and -Wreserved-id-macro. The warning -Wkeyword-macro now is not issued in patterns that are used in configuration scripts: #define inline also for 'const', 'extern' and 'static'. If macro repalcement is identical to macro name, the warning also is not issued: #define volatile volatile And finally if macro replacement is also a keyword identical to the replaced one but decorated with leading/trailing underscores: #define inline __inline #define inline __inline__ #define inline _inline // in MSVC compatibility mode Warning -Wreserved-id-macro is off by default, it could help catching things like: #undef __cplusplus llvm-svn: 224512
2014-12-18 19:14:21 +08:00
enum MacroDiag {
MD_NoWarn, //> Not a reserved identifier
MD_KeywordDef, //> Macro hides keyword, enabled by default
MD_ReservedMacro //> #define of #undef reserved id, disabled by default
};
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Checks if the specified identifier is reserved in the specified
Fixed warnings on redefine keywords and reserved ids. Repared support for warnings -Wkeyword-macro and -Wreserved-id-macro. The warning -Wkeyword-macro now is not issued in patterns that are used in configuration scripts: #define inline also for 'const', 'extern' and 'static'. If macro repalcement is identical to macro name, the warning also is not issued: #define volatile volatile And finally if macro replacement is also a keyword identical to the replaced one but decorated with leading/trailing underscores: #define inline __inline #define inline __inline__ #define inline _inline // in MSVC compatibility mode Warning -Wreserved-id-macro is off by default, it could help catching things like: #undef __cplusplus llvm-svn: 224512
2014-12-18 19:14:21 +08:00
/// language.
/// This function does not check if the identifier is a keyword.
static bool isReservedId(StringRef Text, const LangOptions &Lang) {
// C++ [macro.names], C11 7.1.3:
// All identifiers that begin with an underscore and either an uppercase
// letter or another underscore are always reserved for any use.
if (Text.size() >= 2 && Text[0] == '_' &&
(isUppercase(Text[1]) || Text[1] == '_'))
return true;
// C++ [global.names]
// Each name that contains a double underscore ... is reserved to the
// implementation for any use.
if (Lang.CPlusPlus) {
if (Text.find("__") != StringRef::npos)
return true;
}
return false;
}
[Modules] Honor -fmodule-name when handling private framework modules When skipping building the module for a private framework module, LangOpts.CurrentModule isn't enough for implict modules builds; for instance, in case a private module is built while building a public one, LangOpts.CurrentModule doesn't reflect the -fmodule-name being passed down, but instead the module name which triggered the build. Store the actual -fmodule-name in LangOpts.ModuleName and actually check a name was provided during compiler invocation in order to skip building the private module. rdar://problem/38434694 llvm-svn: 328053
2018-03-21 06:36:39 +08:00
// The -fmodule-name option tells the compiler to textually include headers in
// the specified module, meaning clang won't build the specified module. This is
// useful in a number of situations, for instance, when building a library that
// vends a module map, one might want to avoid hitting intermediate build
Misc typos fixes in ./lib folder Summary: Found via `codespell -q 3 -I ../clang-whitelist.txt -L uint,importd,crasher,gonna,cant,ue,ons,orign,ned` Reviewers: teemperor Reviewed By: teemperor Subscribers: teemperor, jholewinski, jvesely, nhaehnle, whisperity, jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D55475 llvm-svn: 348755
2018-12-10 20:37:46 +08:00
// products containimg the the module map or avoid finding the system installed
[Modules] Honor -fmodule-name when handling private framework modules When skipping building the module for a private framework module, LangOpts.CurrentModule isn't enough for implict modules builds; for instance, in case a private module is built while building a public one, LangOpts.CurrentModule doesn't reflect the -fmodule-name being passed down, but instead the module name which triggered the build. Store the actual -fmodule-name in LangOpts.ModuleName and actually check a name was provided during compiler invocation in order to skip building the private module. rdar://problem/38434694 llvm-svn: 328053
2018-03-21 06:36:39 +08:00
// modulemap for that library.
static bool isForModuleBuilding(Module *M, StringRef CurrentModule,
StringRef ModuleName) {
[Modules] Extend -fmodule-name semantic for frameworks with private modules Assume Foo.framework with two module maps and two modules Foo and Foo_Private. Framework authors need to skip building both Foo and Foo_Private when using -fmodule-name=Foo, since both are part of the framework and used interchangeably during compilation. rdar://problem/37500098 llvm-svn: 325305
2018-02-16 08:12:57 +08:00
StringRef TopLevelName = M->getTopLevelModuleName();
// When building framework Foo, we wanna make sure that Foo *and* Foo_Private
// are textually included and no modules are built for both.
[Modules] Honor -fmodule-name when handling private framework modules When skipping building the module for a private framework module, LangOpts.CurrentModule isn't enough for implict modules builds; for instance, in case a private module is built while building a public one, LangOpts.CurrentModule doesn't reflect the -fmodule-name being passed down, but instead the module name which triggered the build. Store the actual -fmodule-name in LangOpts.ModuleName and actually check a name was provided during compiler invocation in order to skip building the private module. rdar://problem/38434694 llvm-svn: 328053
2018-03-21 06:36:39 +08:00
if (M->getTopLevelModule()->IsFramework && CurrentModule == ModuleName &&
[Modules] Extend -fmodule-name semantic for frameworks with private modules Assume Foo.framework with two module maps and two modules Foo and Foo_Private. Framework authors need to skip building both Foo and Foo_Private when using -fmodule-name=Foo, since both are part of the framework and used interchangeably during compilation. rdar://problem/37500098 llvm-svn: 325305
2018-02-16 08:12:57 +08:00
!CurrentModule.endswith("_Private") && TopLevelName.endswith("_Private"))
TopLevelName = TopLevelName.drop_back(8);
return TopLevelName == CurrentModule;
}
Fixed warnings on redefine keywords and reserved ids. Repared support for warnings -Wkeyword-macro and -Wreserved-id-macro. The warning -Wkeyword-macro now is not issued in patterns that are used in configuration scripts: #define inline also for 'const', 'extern' and 'static'. If macro repalcement is identical to macro name, the warning also is not issued: #define volatile volatile And finally if macro replacement is also a keyword identical to the replaced one but decorated with leading/trailing underscores: #define inline __inline #define inline __inline__ #define inline _inline // in MSVC compatibility mode Warning -Wreserved-id-macro is off by default, it could help catching things like: #undef __cplusplus llvm-svn: 224512
2014-12-18 19:14:21 +08:00
static MacroDiag shouldWarnOnMacroDef(Preprocessor &PP, IdentifierInfo *II) {
Emit warning if define or undef reserved identifier or keyword. Recommit of r223114, reverted in r223120. llvm-svn: 224012
2014-12-11 20:18:08 +08:00
const LangOptions &Lang = PP.getLangOpts();
StringRef Text = II->getName();
Fixed warnings on redefine keywords and reserved ids. Repared support for warnings -Wkeyword-macro and -Wreserved-id-macro. The warning -Wkeyword-macro now is not issued in patterns that are used in configuration scripts: #define inline also for 'const', 'extern' and 'static'. If macro repalcement is identical to macro name, the warning also is not issued: #define volatile volatile And finally if macro replacement is also a keyword identical to the replaced one but decorated with leading/trailing underscores: #define inline __inline #define inline __inline__ #define inline _inline // in MSVC compatibility mode Warning -Wreserved-id-macro is off by default, it could help catching things like: #undef __cplusplus llvm-svn: 224512
2014-12-18 19:14:21 +08:00
if (isReservedId(Text, Lang))
return MD_ReservedMacro;
Emit warning if define or undef reserved identifier or keyword. Recommit of r223114, reverted in r223120. llvm-svn: 224012
2014-12-11 20:18:08 +08:00
if (II->isKeyword(Lang))
Fixed warnings on redefine keywords and reserved ids. Repared support for warnings -Wkeyword-macro and -Wreserved-id-macro. The warning -Wkeyword-macro now is not issued in patterns that are used in configuration scripts: #define inline also for 'const', 'extern' and 'static'. If macro repalcement is identical to macro name, the warning also is not issued: #define volatile volatile And finally if macro replacement is also a keyword identical to the replaced one but decorated with leading/trailing underscores: #define inline __inline #define inline __inline__ #define inline _inline // in MSVC compatibility mode Warning -Wreserved-id-macro is off by default, it could help catching things like: #undef __cplusplus llvm-svn: 224512
2014-12-18 19:14:21 +08:00
return MD_KeywordDef;
if (Lang.CPlusPlus11 && (Text.equals("override") || Text.equals("final")))
return MD_KeywordDef;
return MD_NoWarn;
Emit warning if define or undef reserved identifier or keyword. Recommit of r223114, reverted in r223120. llvm-svn: 224012
2014-12-11 20:18:08 +08:00
}
Fixed warnings on redefine keywords and reserved ids. Repared support for warnings -Wkeyword-macro and -Wreserved-id-macro. The warning -Wkeyword-macro now is not issued in patterns that are used in configuration scripts: #define inline also for 'const', 'extern' and 'static'. If macro repalcement is identical to macro name, the warning also is not issued: #define volatile volatile And finally if macro replacement is also a keyword identical to the replaced one but decorated with leading/trailing underscores: #define inline __inline #define inline __inline__ #define inline _inline // in MSVC compatibility mode Warning -Wreserved-id-macro is off by default, it could help catching things like: #undef __cplusplus llvm-svn: 224512
2014-12-18 19:14:21 +08:00
static MacroDiag shouldWarnOnMacroUndef(Preprocessor &PP, IdentifierInfo *II) {
const LangOptions &Lang = PP.getLangOpts();
StringRef Text = II->getName();
// Do not warn on keyword undef. It is generally harmless and widely used.
if (isReservedId(Text, Lang))
return MD_ReservedMacro;
return MD_NoWarn;
}
Use the name of the file on disk to issue a new diagnostic about non-portable #include and #import paths. Differential Revision: http://reviews.llvm.org/D19843 Corresponding LLVM change: http://reviews.llvm.org/D19842 Re-commit of r272562 after addressing clang-x86-win2008-selfhost failure. llvm-svn: 272584
2016-06-14 04:40:21 +08:00
// Return true if we want to issue a diagnostic by default if we
// encounter this name in a #include with the wrong case. For now,
// this includes the standard C and C++ headers, Posix headers,
// and Boost headers. Improper case for these #includes is a
// potential portability issue.
static bool warnByDefaultOnWrongCase(StringRef Include) {
// If the first component of the path is "boost", treat this like a standard header
// for the purposes of diagnostics.
if (::llvm::sys::path::begin(Include)->equals_lower("boost"))
return true;
// "condition_variable" is the longest standard header name at 18 characters.
// If the include file name is longer than that, it can't be a standard header.
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
static const size_t MaxStdHeaderNameLen = 18u;
Use the name of the file on disk to issue a new diagnostic about non-portable #include and #import paths. Differential Revision: http://reviews.llvm.org/D19843 Corresponding LLVM change: http://reviews.llvm.org/D19842 Re-commit of r272562 after addressing clang-x86-win2008-selfhost failure. llvm-svn: 272584
2016-06-14 04:40:21 +08:00
if (Include.size() > MaxStdHeaderNameLen)
return false;
// Lowercase and normalize the search string.
SmallString<32> LowerInclude{Include};
for (char &Ch : LowerInclude) {
// In the ASCII range?
[Lex] Try to fix a 'comparison is always false' warning. NFC. llvm-svn: 272867
2016-06-16 10:30:33 +08:00
if (static_cast<unsigned char>(Ch) > 0x7f)
Use the name of the file on disk to issue a new diagnostic about non-portable #include and #import paths. Differential Revision: http://reviews.llvm.org/D19843 Corresponding LLVM change: http://reviews.llvm.org/D19842 Re-commit of r272562 after addressing clang-x86-win2008-selfhost failure. llvm-svn: 272584
2016-06-14 04:40:21 +08:00
return false; // Can't be a standard header
// ASCII lowercase:
if (Ch >= 'A' && Ch <= 'Z')
Ch += 'a' - 'A';
// Normalize path separators for comparison purposes.
else if (::llvm::sys::path::is_separator(Ch))
Ch = '/';
}
// The standard C/C++ and Posix headers
return llvm::StringSwitch<bool>(LowerInclude)
// C library headers
.Cases("assert.h", "complex.h", "ctype.h", "errno.h", "fenv.h", true)
.Cases("float.h", "inttypes.h", "iso646.h", "limits.h", "locale.h", true)
.Cases("math.h", "setjmp.h", "signal.h", "stdalign.h", "stdarg.h", true)
.Cases("stdatomic.h", "stdbool.h", "stddef.h", "stdint.h", "stdio.h", true)
.Cases("stdlib.h", "stdnoreturn.h", "string.h", "tgmath.h", "threads.h", true)
.Cases("time.h", "uchar.h", "wchar.h", "wctype.h", true)
// C++ headers for C library facilities
.Cases("cassert", "ccomplex", "cctype", "cerrno", "cfenv", true)
.Cases("cfloat", "cinttypes", "ciso646", "climits", "clocale", true)
.Cases("cmath", "csetjmp", "csignal", "cstdalign", "cstdarg", true)
.Cases("cstdbool", "cstddef", "cstdint", "cstdio", "cstdlib", true)
.Cases("cstring", "ctgmath", "ctime", "cuchar", "cwchar", true)
.Case("cwctype", true)
// C++ library headers
.Cases("algorithm", "fstream", "list", "regex", "thread", true)
.Cases("array", "functional", "locale", "scoped_allocator", "tuple", true)
.Cases("atomic", "future", "map", "set", "type_traits", true)
.Cases("bitset", "initializer_list", "memory", "shared_mutex", "typeindex", true)
.Cases("chrono", "iomanip", "mutex", "sstream", "typeinfo", true)
.Cases("codecvt", "ios", "new", "stack", "unordered_map", true)
.Cases("complex", "iosfwd", "numeric", "stdexcept", "unordered_set", true)
.Cases("condition_variable", "iostream", "ostream", "streambuf", "utility", true)
.Cases("deque", "istream", "queue", "string", "valarray", true)
.Cases("exception", "iterator", "random", "strstream", "vector", true)
.Cases("forward_list", "limits", "ratio", "system_error", true)
// POSIX headers (which aren't also C headers)
.Cases("aio.h", "arpa/inet.h", "cpio.h", "dirent.h", "dlfcn.h", true)
.Cases("fcntl.h", "fmtmsg.h", "fnmatch.h", "ftw.h", "glob.h", true)
.Cases("grp.h", "iconv.h", "langinfo.h", "libgen.h", "monetary.h", true)
.Cases("mqueue.h", "ndbm.h", "net/if.h", "netdb.h", "netinet/in.h", true)
.Cases("netinet/tcp.h", "nl_types.h", "poll.h", "pthread.h", "pwd.h", true)
.Cases("regex.h", "sched.h", "search.h", "semaphore.h", "spawn.h", true)
.Cases("strings.h", "stropts.h", "sys/ipc.h", "sys/mman.h", "sys/msg.h", true)
.Cases("sys/resource.h", "sys/select.h", "sys/sem.h", "sys/shm.h", "sys/socket.h", true)
.Cases("sys/stat.h", "sys/statvfs.h", "sys/time.h", "sys/times.h", "sys/types.h", true)
.Cases("sys/uio.h", "sys/un.h", "sys/utsname.h", "sys/wait.h", "syslog.h", true)
.Cases("tar.h", "termios.h", "trace.h", "ulimit.h", true)
.Cases("unistd.h", "utime.h", "utmpx.h", "wordexp.h", true)
.Default(false);
}
Fixed warnings on redefine keywords and reserved ids. Repared support for warnings -Wkeyword-macro and -Wreserved-id-macro. The warning -Wkeyword-macro now is not issued in patterns that are used in configuration scripts: #define inline also for 'const', 'extern' and 'static'. If macro repalcement is identical to macro name, the warning also is not issued: #define volatile volatile And finally if macro replacement is also a keyword identical to the replaced one but decorated with leading/trailing underscores: #define inline __inline #define inline __inline__ #define inline _inline // in MSVC compatibility mode Warning -Wreserved-id-macro is off by default, it could help catching things like: #undef __cplusplus llvm-svn: 224512
2014-12-18 19:14:21 +08:00
bool Preprocessor::CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef,
bool *ShadowFlag) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Missing macro name?
Preprocessor: support defined() with operator names for MS compatibility Also flesh out missing tests, improve diagnostic QOI and fix a couple of corner cases found in the process. Fixes PR10606. llvm-svn: 209276
2014-05-21 14:13:51 +08:00
if (MacroNameTok.is(tok::eod))
return Diag(MacroNameTok, diag::err_pp_missing_macro_name);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
Keep the IdentifierInfo in the Token for alternative operator keyword The goal of this commit is to fix clang-format so it does not merge tokens when using the alternative spelling keywords. (eg: "not foo" should not become "notfoo") The problem is that Preprocessor::HandleIdentifier used to drop the identifier info from the token for these keyword. This means the first condition of TokenAnnotator::spaceRequiredBefore is not met. We could add explicit check for the spelling in that condition, but I think it is better to keep the IdentifierInfo and handle the operator keyword explicitly when needed. That actually leads to simpler code, and probably slightly more efficient as well. Another side effect of this change is that __identifier(and) will now work as one would expect, removing a FIXME from the MicrosoftExtensions.cpp test Differential Revision: https://reviews.llvm.org/D35172 llvm-svn: 308008
2017-07-14 17:23:40 +08:00
if (!II)
return Diag(MacroNameTok, diag::err_pp_macro_not_identifier);
Allow operator keywords to be #defined in ms-ext mode. Fixes PR10606. I'm not sure if this is the best way to go about it, but I locally enabled this code path without the msext conditional, and all tests pass, except for test/Preprocessor/cxx_oper_keyword.cpp which explicitly checks that operator keywords can't be redefined. I also parsed chromium/win with a clang with and without this patch. It introduced no new errors, but removes 43 existing errors. llvm-svn: 151768
2012-03-01 06:54:43 +08:00
Keep the IdentifierInfo in the Token for alternative operator keyword The goal of this commit is to fix clang-format so it does not merge tokens when using the alternative spelling keywords. (eg: "not foo" should not become "notfoo") The problem is that Preprocessor::HandleIdentifier used to drop the identifier info from the token for these keyword. This means the first condition of TokenAnnotator::spaceRequiredBefore is not met. We could add explicit check for the spelling in that condition, but I think it is better to keep the IdentifierInfo and handle the operator keyword explicitly when needed. That actually leads to simpler code, and probably slightly more efficient as well. Another side effect of this change is that __identifier(and) will now work as one would expect, removing a FIXME from the MicrosoftExtensions.cpp test Differential Revision: https://reviews.llvm.org/D35172 llvm-svn: 308008
2017-07-14 17:23:40 +08:00
if (II->isCPlusPlusOperatorKeyword()) {
Preprocessor: make C++ operator names as macro identifiers a compatible extension With recent changes, this is now a compatible language extension and can be safely enabled with -ms-extensions instead of requiring the full -ms-compatibility MSVC drop-in mode. As such we can now also emit an extension warning under -Wmicrosoft to help users port their code. llvm-svn: 209978
2014-06-01 00:32:22 +08:00
// C++ 2.5p2: Alternative tokens behave the same as its primary token
// except for their spellings.
Diag(MacroNameTok, getLangOpts().MicrosoftExt
? diag::ext_pp_operator_used_as_macro_name
: diag::err_pp_operator_used_as_macro_name)
<< II << MacroNameTok.getKind();
Preprocessor: recover gracefully when C++ operator names are used as macro identifiers This failure mode shows up occasionally when users try to include C headers in C++ projects or when porting from Windows. We might as well recover in the way the user expected, thus avoiding confusing diagnostic messages at point of use. llvm-svn: 209963
2014-05-31 11:38:17 +08:00
// Allow #defining |and| and friends for Microsoft compatibility or
// recovery when legacy C headers are included in C++.
Preprocessor: support defined() with operator names for MS compatibility Also flesh out missing tests, improve diagnostic QOI and fix a couple of corner cases found in the process. Fixes PR10606. llvm-svn: 209276
2014-05-21 14:13:51 +08:00
}
Use enumerators instead of hardcoded integers when processing macro names. llvm-svn: 220572
2014-10-25 01:31:32 +08:00
if ((isDefineUndef != MU_Other) && II->getPPKeywordID() == tok::pp_defined) {
After issuing a diagnostic for undefining or redefining a builtin macro, continue parsing the directive rather than silently discarding it. Allowing undef or redef of __TIME__ and __DATE__ is important to folks who want stable, reproducible builds. llvm-svn: 176540
2013-03-06 08:46:00 +08:00
// Error if defining "defined": C99 6.10.8/4, C++ [cpp.predefined]p4.
Preprocessor: support defined() with operator names for MS compatibility Also flesh out missing tests, improve diagnostic QOI and fix a couple of corner cases found in the process. Fixes PR10606. llvm-svn: 209276
2014-05-21 14:13:51 +08:00
return Diag(MacroNameTok, diag::err_defined_macro_name);
}
[modules] Stop trying to fake up a linear MacroDirective history. Modules builds fundamentally have a non-linear macro history. In the interest of better source fidelity, represent the macro definition information faithfully: we have a linear macro directive history within each module, and at any point we have a unique "latest" local macro directive and a collection of visible imported directives. This also removes the attendent complexity of attempting to create a correct MacroDirective history (which we got wrong in the general case). No functionality change intended. llvm-svn: 236176
2015-04-30 07:20:19 +08:00
if (isDefineUndef == MU_Undef) {
auto *MI = getMacroInfo(II);
if (MI && MI->isBuiltinMacro()) {
// Warn if undefining "__LINE__" and other builtins, per C99 6.10.8/4
// and C++ [cpp.predefined]p4], but allow it as an extension.
Diag(MacroNameTok, diag::ext_pp_undef_builtin_macro);
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fixed warnings on redefine keywords and reserved ids. Repared support for warnings -Wkeyword-macro and -Wreserved-id-macro. The warning -Wkeyword-macro now is not issued in patterns that are used in configuration scripts: #define inline also for 'const', 'extern' and 'static'. If macro repalcement is identical to macro name, the warning also is not issued: #define volatile volatile And finally if macro replacement is also a keyword identical to the replaced one but decorated with leading/trailing underscores: #define inline __inline #define inline __inline__ #define inline _inline // in MSVC compatibility mode Warning -Wreserved-id-macro is off by default, it could help catching things like: #undef __cplusplus llvm-svn: 224512
2014-12-18 19:14:21 +08:00
// If defining/undefining reserved identifier or a keyword, we need to issue
// a warning.
Emit warning if define or undef reserved identifier or keyword. Recommit of r223114, reverted in r223120. llvm-svn: 224012
2014-12-11 20:18:08 +08:00
SourceLocation MacroNameLoc = MacroNameTok.getLocation();
Fixed warnings on redefine keywords and reserved ids. Repared support for warnings -Wkeyword-macro and -Wreserved-id-macro. The warning -Wkeyword-macro now is not issued in patterns that are used in configuration scripts: #define inline also for 'const', 'extern' and 'static'. If macro repalcement is identical to macro name, the warning also is not issued: #define volatile volatile And finally if macro replacement is also a keyword identical to the replaced one but decorated with leading/trailing underscores: #define inline __inline #define inline __inline__ #define inline _inline // in MSVC compatibility mode Warning -Wreserved-id-macro is off by default, it could help catching things like: #undef __cplusplus llvm-svn: 224512
2014-12-18 19:14:21 +08:00
if (ShadowFlag)
*ShadowFlag = false;
Emit warning if define or undef reserved identifier or keyword. Recommit of r223114, reverted in r223120. llvm-svn: 224012
2014-12-11 20:18:08 +08:00
if (!SourceMgr.isInSystemHeader(MacroNameLoc) &&
Use StringRef for MemoryBuffer identifier API (NFC) llvm-svn: 283043
2016-10-02 00:38:28 +08:00
(SourceMgr.getBufferName(MacroNameLoc) != "<built-in>")) {
Fixed warnings on redefine keywords and reserved ids. Repared support for warnings -Wkeyword-macro and -Wreserved-id-macro. The warning -Wkeyword-macro now is not issued in patterns that are used in configuration scripts: #define inline also for 'const', 'extern' and 'static'. If macro repalcement is identical to macro name, the warning also is not issued: #define volatile volatile And finally if macro replacement is also a keyword identical to the replaced one but decorated with leading/trailing underscores: #define inline __inline #define inline __inline__ #define inline _inline // in MSVC compatibility mode Warning -Wreserved-id-macro is off by default, it could help catching things like: #undef __cplusplus llvm-svn: 224512
2014-12-18 19:14:21 +08:00
MacroDiag D = MD_NoWarn;
if (isDefineUndef == MU_Define) {
D = shouldWarnOnMacroDef(*this, II);
}
else if (isDefineUndef == MU_Undef)
D = shouldWarnOnMacroUndef(*this, II);
if (D == MD_KeywordDef) {
// We do not want to warn on some patterns widely used in configuration
// scripts. This requires analyzing next tokens, so do not issue warnings
// now, only inform caller.
if (ShadowFlag)
*ShadowFlag = true;
}
if (D == MD_ReservedMacro)
Diag(MacroNameTok, diag::warn_pp_macro_is_reserved_id);
Emit warning if define or undef reserved identifier or keyword. Recommit of r223114, reverted in r223120. llvm-svn: 224012
2014-12-11 20:18:08 +08:00
}
Preprocessor: support defined() with operator names for MS compatibility Also flesh out missing tests, improve diagnostic QOI and fix a couple of corner cases found in the process. Fixes PR10606. llvm-svn: 209276
2014-05-21 14:13:51 +08:00
// Okay, we got a good identifier.
return false;
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Lex and validate a macro name, which occurs after a
Preprocessor: support defined() with operator names for MS compatibility Also flesh out missing tests, improve diagnostic QOI and fix a couple of corner cases found in the process. Fixes PR10606. llvm-svn: 209276
2014-05-21 14:13:51 +08:00
/// \#define or \#undef.
///
Use enumerators instead of hardcoded integers when processing macro names. llvm-svn: 220572
2014-10-25 01:31:32 +08:00
/// This sets the token kind to eod and discards the rest of the macro line if
/// the macro name is invalid.
///
/// \param MacroNameTok Token that is expected to be a macro name.
Fixed warnings on redefine keywords and reserved ids. Repared support for warnings -Wkeyword-macro and -Wreserved-id-macro. The warning -Wkeyword-macro now is not issued in patterns that are used in configuration scripts: #define inline also for 'const', 'extern' and 'static'. If macro repalcement is identical to macro name, the warning also is not issued: #define volatile volatile And finally if macro replacement is also a keyword identical to the replaced one but decorated with leading/trailing underscores: #define inline __inline #define inline __inline__ #define inline _inline // in MSVC compatibility mode Warning -Wreserved-id-macro is off by default, it could help catching things like: #undef __cplusplus llvm-svn: 224512
2014-12-18 19:14:21 +08:00
/// \param isDefineUndef Context in which macro is used.
/// \param ShadowFlag Points to a flag that is set if macro shadows a keyword.
void Preprocessor::ReadMacroName(Token &MacroNameTok, MacroUse isDefineUndef,
bool *ShadowFlag) {
Preprocessor: support defined() with operator names for MS compatibility Also flesh out missing tests, improve diagnostic QOI and fix a couple of corner cases found in the process. Fixes PR10606. llvm-svn: 209276
2014-05-21 14:13:51 +08:00
// Read the token, don't allow macro expansion on it.
LexUnexpandedToken(MacroNameTok);
if (MacroNameTok.is(tok::code_completion)) {
if (CodeComplete)
Use enumerators instead of hardcoded integers when processing macro names. llvm-svn: 220572
2014-10-25 01:31:32 +08:00
CodeComplete->CodeCompleteMacroName(isDefineUndef == MU_Define);
Preprocessor: support defined() with operator names for MS compatibility Also flesh out missing tests, improve diagnostic QOI and fix a couple of corner cases found in the process. Fixes PR10606. llvm-svn: 209276
2014-05-21 14:13:51 +08:00
setCodeCompletionReached();
LexUnexpandedToken(MacroNameTok);
}
Fixed warnings on redefine keywords and reserved ids. Repared support for warnings -Wkeyword-macro and -Wreserved-id-macro. The warning -Wkeyword-macro now is not issued in patterns that are used in configuration scripts: #define inline also for 'const', 'extern' and 'static'. If macro repalcement is identical to macro name, the warning also is not issued: #define volatile volatile And finally if macro replacement is also a keyword identical to the replaced one but decorated with leading/trailing underscores: #define inline __inline #define inline __inline__ #define inline _inline // in MSVC compatibility mode Warning -Wreserved-id-macro is off by default, it could help catching things like: #undef __cplusplus llvm-svn: 224512
2014-12-18 19:14:21 +08:00
if (!CheckMacroName(MacroNameTok, isDefineUndef, ShadowFlag))
Preprocessor: support defined() with operator names for MS compatibility Also flesh out missing tests, improve diagnostic QOI and fix a couple of corner cases found in the process. Fixes PR10606. llvm-svn: 209276
2014-05-21 14:13:51 +08:00
return;
// Invalid macro name, read and discard the rest of the line and set the
// token kind to tok::eod if necessary.
if (MacroNameTok.isNot(tok::eod)) {
MacroNameTok.setKind(tok::eod);
DiscardUntilEndOfDirective();
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Ensure that the next token is a tok::eod token.
Documentation cleanup: * Add \brief summaries; * Escape # characters in Doxygen comments; * Add \code...\endcode markup for code examples; * Add \verbatim...\endverbatim markup for grammar productions. llvm-svn: 158976
2012-06-22 13:46:07 +08:00
///
/// If not, emit a diagnostic and consume up until the eod. If EnableMacros is
#line is allowed to have macros that expand to nothing after them. llvm-svn: 69401
2009-04-18 07:30:53 +08:00
/// true, then we consider macros that expand to zero tokens as being ok.
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
///
/// Returns the location of the end of the directive.
SourceLocation Preprocessor::CheckEndOfDirective(const char *DirType,
bool EnableMacros) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Token Tmp;
#line is allowed to have macros that expand to nothing after them. llvm-svn: 69401
2009-04-18 07:30:53 +08:00
// Lex unexpanded tokens for most directives: macros might expand to zero
// tokens, causing us to miss diagnosing invalid lines. Some directives (like
// #line) allow empty macros.
if (EnableMacros)
Lex(Tmp);
else
LexUnexpandedToken(Tmp);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// There should be no tokens after the directive, but we allow them as an
// extension.
while (Tmp.is(tok::comment)) // Skip comments in -C mode.
LexUnexpandedToken(Tmp);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
if (Tmp.is(tok::eod))
return Tmp.getLocation();
// Add a fixit in GNU/C99/C++ mode. Don't offer a fixit for strict-C89,
// or if this is a macro-style preprocessing directive, because it is more
// trouble than it is worth to insert /**/ and check that there is no /**/
// in the range also.
FixItHint Hint;
if ((LangOpts.GNUMode || LangOpts.C99 || LangOpts.CPlusPlus) &&
!CurTokenLexer)
Hint = FixItHint::CreateInsertion(Tmp.getLocation(),"//");
Diag(Tmp, diag::ext_pp_extra_tokens_at_eol) << DirType << Hint;
return DiscardUntilEndOfDirective().getEnd();
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
Documentation cleanup: * Add \brief summaries; * Escape # characters in Doxygen comments; * Add \code...\endcode markup for code examples; * Add \verbatim...\endverbatim markup for grammar productions. llvm-svn: 158976
2012-06-22 13:46:07 +08:00
/// SkipExcludedConditionalBlock - We just read a \#if or related directive and
/// decided that the subsequent tokens are in the \#if'd out portion of the
/// file. Lex the rest of the file, until we see an \#endif. If
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
/// FoundNonSkipPortion is true, then we have already emitted code for part of
Documentation cleanup: * Add \brief summaries; * Escape # characters in Doxygen comments; * Add \code...\endcode markup for code examples; * Add \verbatim...\endverbatim markup for grammar productions. llvm-svn: 158976
2012-06-22 13:46:07 +08:00
/// this \#if directive, so \#else/\#elif blocks should never be entered.
/// If ElseOk is true, then \#else directives are ok, if not, then we have
/// already seen one so a \#else directive is a duplicate. When this returns,
/// the caller can lex the first valid token.
[preamble] Also record the "skipping" state of the preprocessor When a preamble ends in a conditional preprocessor block that is being skipped, the preprocessor needs to continue skipping that block when the preamble is used. This fixes PR34570. llvm-svn: 317308
2017-11-03 17:40:07 +08:00
void Preprocessor::SkipExcludedConditionalBlock(SourceLocation HashTokenLoc,
[Lexer] Report more precise skipped regions (PR34166) This patch teaches the preprocessor to report more precise source ranges for code that is skipped due to conditional directives. The new behavior includes the '#' from the opening directive and the full text of the line containing the closing directive in the skipped area. This matches up clang's behavior (we don't IRGen the code between the closing "endif" and the end of a line). This also affects the code coverage implementation. See llvm.org/PR34166 (this also happens to be rdar://problem/23224058). The old behavior (report the end of the skipped range as the end location of the 'endif' token) is preserved for indexing clients. Differential Revision: https://reviews.llvm.org/D36642 llvm-svn: 312947
2017-09-12 04:47:42 +08:00
SourceLocation IfTokenLoc,
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
bool FoundNonSkipPortion,
Introduce a callback to PPCallbacks for lines skipped by the preprocessor. Patch by Jason Haslam! llvm-svn: 140612
2011-09-28 01:32:05 +08:00
bool FoundElse,
SourceLocation ElseLoc) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
++NumSkipped;
Use only explicit bool conversion operator The most common (non-buggy) case are where such objects are used as return expressions in bool-returning functions or as boolean function arguments. In those cases I've used (& added if necessary) a named function to provide the equivalent (or sometimes negative, depending on convenient wording) test. DiagnosticBuilder kept its implicit conversion operator owing to the prevalent use of it in return statements. One bug was found in ExprConstant.cpp involving a comparison of two PointerUnions (PointerUnion did not previously have an operator==, so instead both operands were converted to bool & then compared). A test is included in test/SemaCXX/constant-expression-cxx1y.cpp for the fix (adding operator== to PointerUnion in LLVM). llvm-svn: 181869
2013-05-15 15:37:26 +08:00
assert(!CurTokenLexer && CurPPLexer && "Lexing a macro, not a file?");
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
[preamble] Also record the "skipping" state of the preprocessor When a preamble ends in a conditional preprocessor block that is being skipped, the preprocessor needs to continue skipping that block when the preamble is used. This fixes PR34570. llvm-svn: 317308
2017-11-03 17:40:07 +08:00
if (PreambleConditionalStack.reachedEOFWhileSkipping())
PreambleConditionalStack.clearSkipInfo();
else
CurPPLexer->pushConditionalLevel(IfTokenLoc, /*isSkipping*/ false,
FoundNonSkipPortion, FoundElse);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Enter raw mode to disable identifier lookup (and thus macro expansion),
// disabling warnings, etc.
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
CurPPLexer->LexingRawMode = true;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Token Tok;
Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes. Differential revision: https://reviews.llvm.org/D24115 llvm-svn: 280870
2016-09-08 05:53:17 +08:00
while (true) {
simplify the code for skipping in a #if 0 block. The CurLexer pointer is always non-null because the PTH case exits earlier in the method. llvm-svn: 93794
2010-01-19 06:33:01 +08:00
CurLexer->Lex(Tok);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introduce basic code-completion support for preprocessor directives, e.g., after a "#" we'll suggest #if, #ifdef, etc. llvm-svn: 111943
2010-08-25 03:08:16 +08:00
if (Tok.is(tok::code_completion)) {
if (CodeComplete)
CodeComplete->CodeCompleteInConditionalExclusion();
Support code-completion for C++ inline methods and ObjC buffering methods. Previously we would cut off the source file buffer at the code-completion point; this impeded code-completion inside C++ inline methods and, recently, with buffering ObjC methods. Have the code-completion inserted into the source buffer so that it can be buffered along with a method body. When we actually hit the code-completion point the cut-off lexing or parsing. Fixes rdar://10056932&8319466 llvm-svn: 139086
2011-09-04 11:32:15 +08:00
setCodeCompletionReached();
Introduce basic code-completion support for preprocessor directives, e.g., after a "#" we'll suggest #if, #ifdef, etc. llvm-svn: 111943
2010-08-25 03:08:16 +08:00
continue;
}
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// If this is the end of the buffer, we have an error.
if (Tok.is(tok::eof)) {
Fix recording preamble's conditional stack in skipped PP branches. Summary: This fixes PR34547. `Lexer::LexEndOfFile` handles recording of ConditionalStack for preamble and reporting errors about unmatched conditionalal PP directives. However, SkipExcludedConditionalBlock contianed duplicated logic for reporting errors and clearing ConditionalStack, but not for preamble recording. This fix removes error reporting logic from `SkipExcludedConditionalBlock`, unmatched PP conditionals are now reported inside `Lexer::LexEndOfFile`. Reviewers: erikjv, klimek, bkramer Reviewed By: erikjv Subscribers: nik, cfe-commits Differential Revision: https://reviews.llvm.org/D37700 llvm-svn: 313014
2017-09-12 16:35:57 +08:00
// We don't emit errors for unterminated conditionals here,
Misc typos fixes in ./lib folder Summary: Found via `codespell -q 3 -I ../clang-whitelist.txt -L uint,importd,crasher,gonna,cant,ue,ons,orign,ned` Reviewers: teemperor Reviewed By: teemperor Subscribers: teemperor, jholewinski, jvesely, nhaehnle, whisperity, jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D55475 llvm-svn: 348755
2018-12-10 20:37:46 +08:00
// Lexer::LexEndOfFile can do that properly.
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Just return and let the caller lex after this #include.
[preamble] Also record the "skipping" state of the preprocessor When a preamble ends in a conditional preprocessor block that is being skipped, the preprocessor needs to continue skipping that block when the preamble is used. This fixes PR34570. llvm-svn: 317308
2017-11-03 17:40:07 +08:00
if (PreambleConditionalStack.isRecording())
PreambleConditionalStack.SkipInfo.emplace(
HashTokenLoc, IfTokenLoc, FoundNonSkipPortion, FoundElse, ElseLoc);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
break;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// If this token is not a preprocessor directive, just skip it.
if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine())
continue;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// We just parsed a # character at the start of a line, so we're in
// directive mode. Tell the lexer this so any newlines we see will be
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
// converted into an EOD token (this terminates the macro).
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
CurPPLexer->ParsingPreprocessorDirective = true;
Preproceessor: fix #if skipping under -traditional-cpp. When parsing directives within skipped #if blocks, we don't want to retain any whitespace. Previously we were just skipping comments, but it's not possible to skip comments and retain other whitespace. This change matches the usual behavior for parsing directives (i.e. the behavior outside of skipped #if blocks). <rdar://problem/13267695> llvm-svn: 175840
2013-02-22 08:32:00 +08:00
if (CurLexer) CurLexer->SetKeepWhitespaceMode(false);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Read the next token, the directive flavor.
LexUnexpandedToken(Tok);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// If this isn't an identifier directive (e.g. is "# 1\n" or "#\n", or
// something bogus), skip it.
Introduced raw_identifier token kind. llvm-svn: 122394
2010-12-22 16:23:18 +08:00
if (Tok.isNot(tok::raw_identifier)) {
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
CurPPLexer->ParsingPreprocessorDirective = false;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Restore comment saving mode.
Preprocessor: preserve whitespace in -traditional-cpp mode. Note that unlike GNU cpp we currently do not preserve whitespace in macros (even in -traditional-cpp mode). <rdar://problem/12897179> llvm-svn: 175778
2013-02-22 02:53:19 +08:00
if (CurLexer) CurLexer->resetExtendedTokenMode();
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
continue;
}
// If the first letter isn't i or e, it isn't intesting to us. We know that
// this is safe in the face of spelling differences, because there is no way
// to spell an i/e in a strange way that is another letter. Skipping this
// allows us to avoid looking up the identifier info for #define/#undef and
// other common directives.
Provide and use a safe Token::getRawIdentifier() accessor llvm-svn: 209061
2014-05-17 12:53:25 +08:00
StringRef RI = Tok.getRawIdentifier();
Introduced raw_identifier token kind. llvm-svn: 122394
2010-12-22 16:23:18 +08:00
Provide and use a safe Token::getRawIdentifier() accessor llvm-svn: 209061
2014-05-17 12:53:25 +08:00
char FirstChar = RI[0];
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (FirstChar >= 'a' && FirstChar <= 'z' &&
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
FirstChar != 'i' && FirstChar != 'e') {
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
CurPPLexer->ParsingPreprocessorDirective = false;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Restore comment saving mode.
Preprocessor: preserve whitespace in -traditional-cpp mode. Note that unlike GNU cpp we currently do not preserve whitespace in macros (even in -traditional-cpp mode). <rdar://problem/12897179> llvm-svn: 175778
2013-02-22 02:53:19 +08:00
if (CurLexer) CurLexer->resetExtendedTokenMode();
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
continue;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Get the identifier name without trigraphs or embedded newlines. Note
// that we can't use Tok.getIdentifierInfo() because its lookup is disabled
// when skipping.
Convert to StringRef, avoid a memcpy in the common case. llvm-svn: 92357
2009-12-31 21:32:38 +08:00
char DirectiveBuf[20];
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef Directive;
Provide and use a safe Token::getRawIdentifier() accessor llvm-svn: 209061
2014-05-17 12:53:25 +08:00
if (!Tok.needsCleaning() && RI.size() < 20) {
Directive = RI;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
} else {
std::string DirectiveStr = getSpelling(Tok);
[PP] Replace some uses of unsigned with size_t All values are returned by a method as size_t, and subsequently passed to functions taking a size_t, or used where a size_t is also valid. Better still, two loops (which had an unsigned), can be replaced by a range-based for loop. Differential Revision: http://reviews.llvm.org/D25939 llvm-svn: 285182
2016-10-26 17:58:31 +08:00
size_t IdLen = DirectiveStr.size();
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
if (IdLen >= 20) {
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
CurPPLexer->ParsingPreprocessorDirective = false;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Restore comment saving mode.
Preprocessor: preserve whitespace in -traditional-cpp mode. Note that unlike GNU cpp we currently do not preserve whitespace in macros (even in -traditional-cpp mode). <rdar://problem/12897179> llvm-svn: 175778
2013-02-22 02:53:19 +08:00
if (CurLexer) CurLexer->resetExtendedTokenMode();
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
continue;
}
Convert to StringRef, avoid a memcpy in the common case. llvm-svn: 92357
2009-12-31 21:32:38 +08:00
memcpy(DirectiveBuf, &DirectiveStr[0], IdLen);
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
Directive = StringRef(DirectiveBuf, IdLen);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Convert to StringRef, avoid a memcpy in the common case. llvm-svn: 92357
2009-12-31 21:32:38 +08:00
if (Directive.startswith("if")) {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef Sub = Directive.substr(2);
Convert to StringRef, avoid a memcpy in the common case. llvm-svn: 92357
2009-12-31 21:32:38 +08:00
if (Sub.empty() || // "if"
Sub == "def" || // "ifdef"
Sub == "ndef") { // "ifndef"
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// We know the entire #if/#ifdef/#ifndef block will be skipped, don't
// bother parsing the condition.
DiscardUntilEndOfDirective();
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
CurPPLexer->pushConditionalLevel(Tok.getLocation(), /*wasskipping*/true,
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
/*foundnonskip*/false,
Fix PR8654, ensuring each branch of an #if, #elif, #else, ... chain receives a PPCallback. Patch by Richard Smith. llvm-svn: 122755
2011-01-04 01:40:17 +08:00
/*foundelse*/false);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
Convert to StringRef, avoid a memcpy in the common case. llvm-svn: 92357
2009-12-31 21:32:38 +08:00
} else if (Directive[0] == 'e') {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef Sub = Directive.substr(1);
Convert to StringRef, avoid a memcpy in the common case. llvm-svn: 92357
2009-12-31 21:32:38 +08:00
if (Sub == "ndif") { // "endif"
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
PPConditionalInfo CondInfo;
CondInfo.WasSkipping = true; // Silence bogus warning.
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
bool InCond = CurPPLexer->popConditionalLevel(CondInfo);
Change all self assignments X=X to (void)X, so that we can turn on a new gcc warning that complains on self-assignments and self-initializations. Fix one bug found by the warning, in which one clang::OverloadCandidate constructor failed to initialize its FunctionTemplate member. llvm-svn: 122459
2010-12-23 09:01:28 +08:00
(void)InCond; // Silence warning in no-asserts mode.
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
assert(!InCond && "Can't be skipping if not in a conditional!");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// If we popped the outermost skipping block, we're done skipping!
[preprocessor] Enhance the preprocessor callbacks: -Add location parameter for the directives callbacks -Skip callbacks if the directive is inside a skipped range. -Make sure the directive callbacks are invoked in source order. llvm-svn: 152017
2012-03-05 13:48:09 +08:00
if (!CondInfo.WasSkipping) {
Add testing for CommentHandler, and fix a bug where trailing comments in #else and #endif in non-skipped blocks were not passed to the CommentHandler. Patch by Andy Gibbs! llvm-svn: 159119
2012-06-25 07:56:26 +08:00
// Restore the value of LexingRawMode so that trailing comments
// are handled correctly, if we've reached the outermost block.
CurPPLexer->LexingRawMode = false;
Do not complain about junk on the end of a #endif in a skipped block. Such junk is permitted by all relevant language standards. Patch by Andy Gibbs! llvm-svn: 158883
2012-06-21 08:35:03 +08:00
CheckEndOfDirective("endif");
Add testing for CommentHandler, and fix a bug where trailing comments in #else and #endif in non-skipped blocks were not passed to the CommentHandler. Patch by Andy Gibbs! llvm-svn: 159119
2012-06-25 07:56:26 +08:00
CurPPLexer->LexingRawMode = true;
[preprocessor] Enhance the preprocessor callbacks: -Add location parameter for the directives callbacks -Skip callbacks if the directive is inside a skipped range. -Make sure the directive callbacks are invoked in source order. llvm-svn: 152017
2012-03-05 13:48:09 +08:00
if (Callbacks)
Callbacks->Endif(Tok.getLocation(), CondInfo.IfLoc);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
break;
Do not complain about junk on the end of a #endif in a skipped block. Such junk is permitted by all relevant language standards. Patch by Andy Gibbs! llvm-svn: 158883
2012-06-21 08:35:03 +08:00
} else {
DiscardUntilEndOfDirective();
[preprocessor] Enhance the preprocessor callbacks: -Add location parameter for the directives callbacks -Skip callbacks if the directive is inside a skipped range. -Make sure the directive callbacks are invoked in source order. llvm-svn: 152017
2012-03-05 13:48:09 +08:00
}
Convert to StringRef, avoid a memcpy in the common case. llvm-svn: 92357
2009-12-31 21:32:38 +08:00
} else if (Sub == "lse") { // "else".
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// #else directive in a skipping conditional. If not in some other
// skipping conditional, and if #else hasn't already been seen, enter it
// as a non-skipping conditional.
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// If this is a #else with a #else before it, report the error.
if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_else_after_else);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Note that we've seen a #else in this conditional.
CondInfo.FoundElse = true;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// If the conditional is at the top level, and the #if block wasn't
// entered, enter the #else block now.
if (!CondInfo.WasSkipping && !CondInfo.FoundNonSkip) {
CondInfo.FoundNonSkip = true;
Add testing for CommentHandler, and fix a bug where trailing comments in #else and #endif in non-skipped blocks were not passed to the CommentHandler. Patch by Andy Gibbs! llvm-svn: 159119
2012-06-25 07:56:26 +08:00
// Restore the value of LexingRawMode so that trailing comments
// are handled correctly.
CurPPLexer->LexingRawMode = false;
Only ignore extra tokens after #else if we skip it, otherwise warn. Fixes rdar://9475098. llvm-svn: 131788
2011-05-21 12:26:04 +08:00
CheckEndOfDirective("else");
Add testing for CommentHandler, and fix a bug where trailing comments in #else and #endif in non-skipped blocks were not passed to the CommentHandler. Patch by Andy Gibbs! llvm-svn: 159119
2012-06-25 07:56:26 +08:00
CurPPLexer->LexingRawMode = true;
[preprocessor] Enhance the preprocessor callbacks: -Add location parameter for the directives callbacks -Skip callbacks if the directive is inside a skipped range. -Make sure the directive callbacks are invoked in source order. llvm-svn: 152017
2012-03-05 13:48:09 +08:00
if (Callbacks)
Callbacks->Else(Tok.getLocation(), CondInfo.IfLoc);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
break;
Only ignore extra tokens after #else if we skip it, otherwise warn. Fixes rdar://9475098. llvm-svn: 131788
2011-05-21 12:26:04 +08:00
} else {
DiscardUntilEndOfDirective(); // C99 6.10p4.
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
Convert to StringRef, avoid a memcpy in the common case. llvm-svn: 92357
2009-12-31 21:32:38 +08:00
} else if (Sub == "lif") { // "elif".
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Enea Zaffanella's fix for the PPCallbacks Elif callback, with a slight re-org, and an update of the new PPCallbacks test (soon to be moved to clang from extra), rather the unittest. llvm-svn: 196407
2013-12-05 04:19:30 +08:00
// If this is a #elif with a #else before it, report the error.
if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_elif_after_else);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// If this is in a skipping block or if we're already handled this #if
// block, don't bother parsing the condition.
Remove random windows line endings that snuck into the middle of this code. llvm-svn: 351633
2019-01-19 14:36:00 +08:00
if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) {
DiscardUntilEndOfDirective();
} else {
// Restore the value of LexingRawMode so that identifiers are
// looked up, etc, inside the #elif expression.
assert(CurPPLexer->LexingRawMode && "We have to be skipping here!");
CurPPLexer->LexingRawMode = false;
IdentifierInfo *IfNDefMacro = nullptr;
DirectiveEvalResult DER = EvaluateDirectiveExpression(IfNDefMacro);
const bool CondValue = DER.Conditional;
CurPPLexer->LexingRawMode = true;
if (Callbacks) {
Callbacks->Elif(
Tok.getLocation(), DER.ExprRange,
(CondValue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False),
CondInfo.IfLoc);
}
// If this condition is true, enter it!
if (CondValue) {
Enea Zaffanella's fix for the PPCallbacks Elif callback, with a slight re-org, and an update of the new PPCallbacks test (soon to be moved to clang from extra), rather the unittest. llvm-svn: 196407
2013-12-05 04:19:30 +08:00
CondInfo.FoundNonSkip = true;
break;
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
}
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
CurPPLexer->ParsingPreprocessorDirective = false;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Restore comment saving mode.
Preprocessor: preserve whitespace in -traditional-cpp mode. Note that unlike GNU cpp we currently do not preserve whitespace in macros (even in -traditional-cpp mode). <rdar://problem/12897179> llvm-svn: 175778
2013-02-22 02:53:19 +08:00
if (CurLexer) CurLexer->resetExtendedTokenMode();
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
// Finally, if we are out of the conditional (saw an #endif or ran off the end
// of the file, just stop skipping and return to lexing whatever came after
// the #if block.
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
CurPPLexer->LexingRawMode = false;
Introduce a callback to PPCallbacks for lines skipped by the preprocessor. Patch by Jason Haslam! llvm-svn: 140612
2011-09-28 01:32:05 +08:00
[PCH] Serialize skipped preprocessor ranges The skipped preprocessor ranges are now serialized in the AST PCH file. This fixes, for example, libclang's clang_getSkippedRanges() returning zero ranges after reparsing a translation unit. Differential Revision: https://reviews.llvm.org/D20124 llvm-svn: 322503
2018-01-16 03:14:16 +08:00
// The last skipped range isn't actually skipped yet if it's truncated
// by the end of the preamble; we'll resume parsing after the preamble.
if (Callbacks && (Tok.isNot(tok::eof) || !isRecordingPreamble()))
[Lexer] Report more precise skipped regions (PR34166) This patch teaches the preprocessor to report more precise source ranges for code that is skipped due to conditional directives. The new behavior includes the '#' from the opening directive and the full text of the line containing the closing directive in the skipped area. This matches up clang's behavior (we don't IRGen the code between the closing "endif" and the end of a line). This also affects the code coverage implementation. See llvm.org/PR34166 (this also happens to be rdar://problem/23224058). The old behavior (report the end of the skipped range as the end location of the 'endif' token) is preserved for indexing clients. Differential Revision: https://reviews.llvm.org/D36642 llvm-svn: 312947
2017-09-12 04:47:42 +08:00
Callbacks->SourceRangeSkipped(
[preamble] Also record the "skipping" state of the preprocessor When a preamble ends in a conditional preprocessor block that is being skipped, the preprocessor needs to continue skipping that block when the preamble is used. This fixes PR34570. llvm-svn: 317308
2017-11-03 17:40:07 +08:00
SourceRange(HashTokenLoc, CurPPLexer->getSourceLocation()),
[Lexer] Report more precise skipped regions (PR34166) This patch teaches the preprocessor to report more precise source ranges for code that is skipped due to conditional directives. The new behavior includes the '#' from the opening directive and the full text of the line containing the closing directive in the skipped area. This matches up clang's behavior (we don't IRGen the code between the closing "endif" and the end of a line). This also affects the code coverage implementation. See llvm.org/PR34166 (this also happens to be rdar://problem/23224058). The old behavior (report the end of the skipped range as the end location of the 'endif' token) is preserved for indexing clients. Differential Revision: https://reviews.llvm.org/D36642 llvm-svn: 312947
2017-09-12 04:47:42 +08:00
Tok.getLocation());
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
[modules] Properly attribute macros to modules if they're in a file textually included into a file in the module. llvm-svn: 235661
2015-04-24 06:58:06 +08:00
Module *Preprocessor::getModuleForLocation(SourceLocation Loc) {
[modules] Flatten -fmodule-name= and -fmodule-implementation-of= into a single option. Previously these options could both be used to specify that you were compiling the implementation file of a module, with a different set of minor bugs in each case. This change removes -fmodule-implementation-of, and instead tracks a flag to determine whether we're currently building a module. -fmodule-name now behaves the same way that -fmodule-implementation-of previously did. llvm-svn: 261372
2016-02-20 06:25:36 +08:00
if (!SourceMgr.isInMainFile(Loc)) {
// Try to determine the module of the include directive.
// FIXME: Look into directly passing the FileEntry from LookupFile instead.
FileID IDOfIncl = SourceMgr.getFileID(SourceMgr.getExpansionLoc(Loc));
if (const FileEntry *EntryOfIncl = SourceMgr.getFileEntryForID(IDOfIncl)) {
// The include comes from an included file.
return HeaderInfo.getModuleMap()
.findModuleForHeader(EntryOfIncl)
.getModule();
}
Module use declarations (II) Review: http://llvm-reviews.chandlerc.com/D1546. I have picked up this patch form Lawrence (http://llvm-reviews.chandlerc.com/D1063) and did a few changes. From the original change description (updated as appropriate): This patch adds a check that ensures that modules only use modules they have so declared. To this end, it adds a statement on intended module use to the module.map grammar: use module-id A module can then only use headers from other modules if it 'uses' them. This enforcement is off by default, but may be turned on with the new option -fmodules-decluse. When enforcing the module semantics, we also need to consider a source file part of a module. This is achieved with a compiler option -fmodule-name=<module-id>. The compiler at present only applies restrictions to the module directly being built. llvm-svn: 191283
2013-09-24 17:14:14 +08:00
}
[modules] Flatten -fmodule-name= and -fmodule-implementation-of= into a single option. Previously these options could both be used to specify that you were compiling the implementation file of a module, with a different set of minor bugs in each case. This change removes -fmodule-implementation-of, and instead tracks a flag to determine whether we're currently building a module. -fmodule-name now behaves the same way that -fmodule-implementation-of previously did. llvm-svn: 261372
2016-02-20 06:25:36 +08:00
// This is either in the main file or not in a file at all. It belongs
// to the current module, if there is one.
return getLangOpts().CurrentModule.empty()
? nullptr
: HeaderInfo.lookupModule(getLangOpts().CurrentModule);
Module use declarations (II) Review: http://llvm-reviews.chandlerc.com/D1546. I have picked up this patch form Lawrence (http://llvm-reviews.chandlerc.com/D1063) and did a few changes. From the original change description (updated as appropriate): This patch adds a check that ensures that modules only use modules they have so declared. To this end, it adds a statement on intended module use to the module.map grammar: use module-id A module can then only use headers from other modules if it 'uses' them. This enforcement is off by default, but may be turned on with the new option -fmodules-decluse. When enforcing the module semantics, we also need to consider a source file part of a module. This is achieved with a compiler option -fmodule-name=<module-id>. The compiler at present only applies restrictions to the module directly being built. llvm-svn: 191283
2013-09-24 17:14:14 +08:00
}
[modules] When diagnosing a missing module import, suggest adding a #include if the current language doesn't have an import syntax and we can figure out a suitable file to include. llvm-svn: 267802
2016-04-28 05:57:05 +08:00
const FileEntry *
Preprocessor::getModuleHeaderToIncludeForDiagnostics(SourceLocation IncLoc,
Remove last (unnecessary) use of mapping from SourceLocation to Module and remove the mechanism for doing so. This mechanism was incorrect in the presence of preprocessed modules (and #pragma clang module begin/end). llvm-svn: 303469
2017-05-20 07:49:00 +08:00
Module *M,
[modules] When diagnosing a missing module import, suggest adding a #include if the current language doesn't have an import syntax and we can figure out a suitable file to include. llvm-svn: 267802
2016-04-28 05:57:05 +08:00
SourceLocation Loc) {
Remove last (unnecessary) use of mapping from SourceLocation to Module and remove the mechanism for doing so. This mechanism was incorrect in the presence of preprocessed modules (and #pragma clang module begin/end). llvm-svn: 303469
2017-05-20 07:49:00 +08:00
assert(M && "no module to include");
[modules] When diagnosing a missing module import, suggest adding a #include if the current language doesn't have an import syntax and we can figure out a suitable file to include. llvm-svn: 267802
2016-04-28 05:57:05 +08:00
// If we have a module import syntax, we shouldn't include a header to
// make a particular module visible.
NFC: Remove the ObjC1/ObjC2 distinction from clang (and related projects) We haven't supported compiling ObjC1 for a long time (and never will again), so there isn't any reason to keep these separate. This patch replaces LangOpts::ObjC1 and LangOpts::ObjC2 with LangOpts::ObjC. Differential revision: https://reviews.llvm.org/D53547 llvm-svn: 345637
2018-10-31 04:31:30 +08:00
if (getLangOpts().ObjC)
[modules] When diagnosing a missing module import, suggest adding a #include if the current language doesn't have an import syntax and we can figure out a suitable file to include. llvm-svn: 267802
2016-04-28 05:57:05 +08:00
return nullptr;
Module *TopM = M->getTopLevelModule();
Module *IncM = getModuleForLocation(IncLoc);
// Walk up through the include stack, looking through textual headers of M
// until we hit a non-textual header that we can #include. (We assume textual
// headers of a module with non-textual headers aren't meant to be used to
// import entities from the module.)
auto &SM = getSourceManager();
while (!Loc.isInvalid() && !SM.isInMainFile(Loc)) {
auto ID = SM.getFileID(SM.getExpansionLoc(Loc));
auto *FE = SM.getFileEntryForID(ID);
Support lazy stat'ing of files referenced by module maps. This patch adds support for a `header` declaration in a module map to specify certain `stat` information (currently, size and mtime) about that header file. This has two purposes: - It removes the need to eagerly `stat` every file referenced by a module map. Instead, we track a list of unresolved header files with each size / mtime (actually, for simplicity, we track submodules with such headers), and when attempting to look up a header file based on a `FileEntry`, we check if there are any unresolved header directives with that `FileEntry`'s size / mtime and perform deferred `stat`s if so. - It permits a preprocessed module to be compiled without the original files being present on disk. The only reason we used to need those files was to get the `stat` information in order to do header -> module lookups when using the module. If we're provided with the `stat` information in the preprocessed module, we can avoid requiring the files to exist. Unlike most `header` directives, if a `header` directive with `stat` information has no corresponding on-disk file the enclosing module is *not* marked unavailable (so that behavior is consistent regardless of whether we've resolved a header directive, and so that preprocessed modules don't get marked unavailable). We could actually do this for all `header` directives: the only reason we mark the module unavailable if headers are missing is to give a diagnostic slightly earlier (rather than waiting until we actually try to build the module / load and validate its .pcm file). Differential Revision: https://reviews.llvm.org/D33703 llvm-svn: 304515
2017-06-02 09:55:39 +08:00
if (!FE)
break;
[modules] When diagnosing a missing module import, suggest adding a #include if the current language doesn't have an import syntax and we can figure out a suitable file to include. llvm-svn: 267802
2016-04-28 05:57:05 +08:00
bool InTextualHeader = false;
for (auto Header : HeaderInfo.getModuleMap().findAllModulesForHeader(FE)) {
if (!Header.getModule()->isSubModuleOf(TopM))
continue;
if (!(Header.getRole() & ModuleMap::TextualHeader)) {
// If this is an accessible, non-textual header of M's top-level module
// that transitively includes the given location and makes the
// corresponding module visible, this is the thing to #include.
if (Header.isAccessibleFrom(IncM))
return FE;
// It's in a private header; we can't #include it.
// FIXME: If there's a public header in some module that re-exports it,
// then we could suggest including that, but it's not clear that's the
// expected way to make this entity visible.
continue;
}
InTextualHeader = true;
}
if (!InTextualHeader)
break;
Loc = SM.getIncludeLoc(ID);
}
return nullptr;
}
Add a 'RawPath' parameter to the PPCallbacks interface. This allows clients to observe the exact path through which an #included file was located. This is very useful when trying to record and replay inclusion operations without it beind influenced by the aggressive caching done inside the FileManager to avoid redundant system calls and filesystem operations. The work to compute and return this is only done in the presence of callbacks, so it should have no effect on normal compilation. Patch by Manuel Klimek. llvm-svn: 127742
2011-03-17 02:34:36 +08:00
const FileEntry *Preprocessor::LookupFile(
Preprocessor: Suppress -Wnonportable-include-path for header maps If a file search involves a header map, suppress -Wnonportable-include-path. It's firing lots of false positives for framework authors internally, and it's not trivial to fix. Consider a framework called "Foo" with a main (installed) framework header "Foo/Foo.h". It's atypical for "Foo.h" to actually live inside a directory called "Foo" in the source repository. Instead, the build system generates a header map while building the framework. If Foo.h lives at the top-level of the source repository (common), and the git repo is called ssh://some.url/foo.git, then the header map will have something like: Foo/Foo.h -> /Users/myname/code/foo/Foo.h where "/Users/myname/code/foo" is the clone of ssh://some.url/foo.git. After #import <Foo/Foo.h>, the current implementation of -Wnonportable-include-path will falsely assume that Foo.h was found in a nonportable way, because of the name of the git clone (.../foo/Foo.h). However, that directory name was not involved in the header search at all. This commit adds an extra parameter to Preprocessor::LookupFile and HeaderSearch::LookupFile to track if the search used a header map, making it easy to suppress the warning. Longer term, once we find a way to avoid the false positive, we should turn the warning back on. rdar://problem/28863903 llvm-svn: 301592
2017-04-28 05:41:51 +08:00
SourceLocation FilenameLoc, StringRef Filename, bool isAngled,
const DirectoryLookup *FromDir, const FileEntry *FromFile,
const DirectoryLookup *&CurDir, SmallVectorImpl<char> *SearchPath,
Add an experimental flag -fauto-module-import that automatically turns #include or #import direcctives of framework headers into module imports of the corresponding framework module. llvm-svn: 139860
2011-09-16 06:00:41 +08:00
SmallVectorImpl<char> *RelativePath,
[Preprocessor] Add a note with framework location for "file not found" error. When a framework with the same name is available at multiple framework search paths, we use the first matching location. If a framework at this location doesn't have all the headers, it can be confusing for developers because they see only an error `'Foo/Foo.h' file not found`, can find the complete framework with required header, and don't know the incomplete framework was used instead. Add a note explaining a framework without required header was found. Also mention framework directory path to make it easier to find the incomplete framework. rdar://problem/39246514 Reviewers: arphaman, erik.pilkington, jkorous Reviewed By: jkorous Subscribers: jkorous, dexonsmith, cfe-commits Differential Revision: https://reviews.llvm.org/D56561 llvm-svn: 353231
2019-02-06 06:34:55 +08:00
ModuleMap::KnownHeader *SuggestedModule, bool *IsMapped,
bool *IsFrameworkFound, bool SkipCache) {
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
Module *RequestingModule = getModuleForLocation(FilenameLoc);
[modules] Don't diagnose non-modular includes from modular files that are implementation units of modules rather than interface units. llvm-svn: 263449
2016-03-15 01:52:37 +08:00
bool RequestingModuleIsModuleInterface = !SourceMgr.isInMainFile(FilenameLoc);
Refactor module lookup when looking up a header file, and wire through the requesting module. No functionality change. llvm-svn: 250554
2015-10-17 05:42:56 +08:00
Implement MSVC header search algorithm in MicrosoftMode. Follows algorithm described here: http://msdn.microsoft.com/en-us/library/36k2cdd4.aspx llvm-svn: 198082
2013-12-28 03:46:16 +08:00
// If the header lookup mechanism may be relative to the current inclusion
// stack, record the parent #includes.
Correctly implement -include search logic. According to the gcc docs, -include uses the current working directory for the lookup instead of the main source file. This patch gets rid of NormalizeIncludePath (which relied on an implementation detail of FileManager / FileEntry for the include path logic to work), and instead hands the correct lookup information down to LookupFile. This will allow us to change the FileEntry's behavior regarding its Name caching. llvm-svn: 215433
2014-08-12 16:25:57 +08:00
SmallVector<std::pair<const FileEntry *, const DirectoryEntry *>, 16>
Includers;
Modules: set SystemHeader to true if we are building a system module. If we are processing a #include from a module build, we should treat it as a system header if we're building a system module. Passing an optional flag to HeaderSearch::LookupFile. Before this, the testing case will crash when accessing a freed FileEntry. rdar://26214027 llvm-svn: 269730
2016-05-17 10:15:12 +08:00
bool BuildSystemModule = false;
[modules] Add support for #include_next. #include_next interacts poorly with modules: it depends on where in the list of include paths the current file was found. Files covered by module maps are not found in include search paths when building the module (and are not found in include search paths when @importing the module either), so this isn't really meaningful. Instead, we fake up the result that #include_next *should* have given: find the first path that would have resulted in the given file being picked, and search from there onwards. llvm-svn: 220177
2014-10-20 08:15:49 +08:00
if (!FromDir && !FromFile) {
this massive patch introduces a simple new abstraction: it makes "FileID" a concept that is now enforced by the compiler's type checker instead of yet-another-random-unsigned floating around. This is an important distinction from the "FileID" currently tracked by SourceLocation. *That* FileID may refer to the start of a file or to a chunk within it. The new FileID *only* refers to the file (and its #include stack and eventually #line data), it cannot refer to a chunk. FileID is a completely opaque datatype to all clients, only SourceManager is allowed to poke and prod it. llvm-svn: 62407
2009-01-17 14:22:33 +08:00
FileID FID = getCurrentFileLexer()->getFileID();
Implement MSVC header search algorithm in MicrosoftMode. Follows algorithm described here: http://msdn.microsoft.com/en-us/library/36k2cdd4.aspx llvm-svn: 198082
2013-12-28 03:46:16 +08:00
const FileEntry *FileEnt = SourceMgr.getFileEntryForID(FID);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fix PR3464 by searching for headers from the predefines buffer as if the #include happened from the main file. llvm-svn: 63764
2009-02-05 03:45:07 +08:00
// If there is no file entry associated with this file, it must be the
[modules] Track how 'header' directives were written in module map files, rather than trying to extract this information from the FileEntry after the fact. This has a number of beneficial effects. For instance, diagnostic messages for failed module builds give a path relative to the "module root" rather than an absolute file path, and the contents of the module includes file is no longer dependent on what files the including TU happened to inspect prior to triggering the module build. llvm-svn: 223095
2014-12-02 08:08:08 +08:00
// predefines buffer or the module includes buffer. Any other file is not
// lexed with a normal lexer, so it won't be scanned for preprocessor
// directives.
//
// If we have the predefines buffer, resolve #include references (which come
// from the -include command line argument) from the current working
// directory instead of relative to the main file.
//
// If we have the module includes buffer, resolve #include references (which
// come from header declarations in the module map) relative to the module
// map file.
Correctly implement -include search logic. According to the gcc docs, -include uses the current working directory for the lookup instead of the main source file. This patch gets rid of NormalizeIncludePath (which relied on an implementation detail of FileManager / FileEntry for the include path logic to work), and instead hands the correct lookup information down to LookupFile. This will allow us to change the FileEntry's behavior regarding its Name caching. llvm-svn: 215433
2014-08-12 16:25:57 +08:00
if (!FileEnt) {
Modules: set SystemHeader to true if we are building a system module. If we are processing a #include from a module build, we should treat it as a system header if we're building a system module. Passing an optional flag to HeaderSearch::LookupFile. Before this, the testing case will crash when accessing a freed FileEntry. rdar://26214027 llvm-svn: 269730
2016-05-17 10:15:12 +08:00
if (FID == SourceMgr.getMainFileID() && MainFileDir) {
[modules] Track how 'header' directives were written in module map files, rather than trying to extract this information from the FileEntry after the fact. This has a number of beneficial effects. For instance, diagnostic messages for failed module builds give a path relative to the "module root" rather than an absolute file path, and the contents of the module includes file is no longer dependent on what files the including TU happened to inspect prior to triggering the module build. llvm-svn: 223095
2014-12-02 08:08:08 +08:00
Includers.push_back(std::make_pair(nullptr, MainFileDir));
Modules: set SystemHeader to true if we are building a system module. If we are processing a #include from a module build, we should treat it as a system header if we're building a system module. Passing an optional flag to HeaderSearch::LookupFile. Before this, the testing case will crash when accessing a freed FileEntry. rdar://26214027 llvm-svn: 269730
2016-05-17 10:15:12 +08:00
BuildSystemModule = getCurrentModule()->IsSystem;
} else if ((FileEnt =
[modules] Track how 'header' directives were written in module map files, rather than trying to extract this information from the FileEntry after the fact. This has a number of beneficial effects. For instance, diagnostic messages for failed module builds give a path relative to the "module root" rather than an absolute file path, and the contents of the module includes file is no longer dependent on what files the including TU happened to inspect prior to triggering the module build. llvm-svn: 223095
2014-12-02 08:08:08 +08:00
SourceMgr.getFileEntryForID(SourceMgr.getMainFileID())))
Correctly implement -include search logic. According to the gcc docs, -include uses the current working directory for the lookup instead of the main source file. This patch gets rid of NormalizeIncludePath (which relied on an implementation detail of FileManager / FileEntry for the include path logic to work), and instead hands the correct lookup information down to LookupFile. This will allow us to change the FileEntry's behavior regarding its Name caching. llvm-svn: 215433
2014-08-12 16:25:57 +08:00
Includers.push_back(std::make_pair(FileEnt, FileMgr.getDirectory(".")));
} else {
Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir()));
}
Implement MSVC header search algorithm in MicrosoftMode. Follows algorithm described here: http://msdn.microsoft.com/en-us/library/36k2cdd4.aspx llvm-svn: 198082
2013-12-28 03:46:16 +08:00
// MSVC searches the current include stack from top to bottom for
// headers included by quoted include directives.
// See: http://msdn.microsoft.com/en-us/library/36k2cdd4.aspx
Rename language option MicrosoftMode to MSVCCompat There's been long-standing confusion over the role of these two options. This commit makes the necessary changes to differentiate them clearly, following up from r198936. MicrosoftExt (aka. fms-extensions): Enable largely unobjectionable Microsoft language extensions to ease portability. This mode, also supported by gcc, is used for building software like FreeBSD and Linux kernel extensions that share code with Windows drivers. MSVCCompat (aka. -fms-compatibility, formerly MicrosoftMode): Turn on a special mode supporting 'heinous' extensions for drop-in compatibility with the Microsoft Visual C++ product. Standards-compilant C and C++ code isn't guaranteed to work in this mode. Implies MicrosoftExt. Note that full -fms-compatibility mode is currently enabled by default on the Windows target, which may need tuning to serve as a reasonable default. See cfe-commits for the full discourse, thread 'r198497 - Move MS predefined type_info out of InitializePredefinedMacros' No change in behaviour. llvm-svn: 199209
2014-01-14 20:51:41 +08:00
if (LangOpts.MSVCCompat && !isAngled) {
[PP] Replace some uses of unsigned with size_t All values are returned by a method as size_t, and subsequently passed to functions taking a size_t, or used where a size_t is also valid. Better still, two loops (which had an unsigned), can be replaced by a range-based for loop. Differential Revision: http://reviews.llvm.org/D25939 llvm-svn: 285182
2016-10-26 17:58:31 +08:00
for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) {
Implement MSVC header search algorithm in MicrosoftMode. Follows algorithm described here: http://msdn.microsoft.com/en-us/library/36k2cdd4.aspx llvm-svn: 198082
2013-12-28 03:46:16 +08:00
if (IsFileLexer(ISEntry))
Replace SM.getFileEntryForID(Lexer->getFileID()) with Lexer->getFileEntry(). llvm-svn: 255993
2015-12-18 18:30:12 +08:00
if ((FileEnt = ISEntry.ThePPLexer->getFileEntry()))
Correctly implement -include search logic. According to the gcc docs, -include uses the current working directory for the lookup instead of the main source file. This patch gets rid of NormalizeIncludePath (which relied on an implementation detail of FileManager / FileEntry for the include path logic to work), and instead hands the correct lookup information down to LookupFile. This will allow us to change the FileEntry's behavior regarding its Name caching. llvm-svn: 215433
2014-08-12 16:25:57 +08:00
Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir()));
Implement MSVC header search algorithm in MicrosoftMode. Follows algorithm described here: http://msdn.microsoft.com/en-us/library/36k2cdd4.aspx llvm-svn: 198082
2013-12-28 03:46:16 +08:00
}
Fix PR3464 by searching for headers from the predefines buffer as if the #include happened from the main file. llvm-svn: 63764
2009-02-05 03:45:07 +08:00
}
move PP::LookupFile from PPLexerChange -> PPDirectives.cpp llvm-svn: 48082
2008-03-09 12:17:44 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
move PP::LookupFile from PPLexerChange -> PPDirectives.cpp llvm-svn: 48082
2008-03-09 12:17:44 +08:00
CurDir = CurDirLookup;
[modules] Add support for #include_next. #include_next interacts poorly with modules: it depends on where in the list of include paths the current file was found. Files covered by module maps are not found in include search paths when building the module (and are not found in include search paths when @importing the module either), so this isn't really meaningful. Instead, we fake up the result that #include_next *should* have given: find the first path that would have resulted in the given file being picked, and search from there onwards. llvm-svn: 220177
2014-10-20 08:15:49 +08:00
if (FromFile) {
// We're supposed to start looking from after a particular file. Search
// the include path until we find that file or run out of files.
const DirectoryLookup *TmpCurDir = CurDir;
const DirectoryLookup *TmpFromDir = nullptr;
while (const FileEntry *FE = HeaderInfo.LookupFile(
Filename, FilenameLoc, isAngled, TmpFromDir, TmpCurDir,
Refactor module lookup when looking up a header file, and wire through the requesting module. No functionality change. llvm-svn: 250554
2015-10-17 05:42:56 +08:00
Includers, SearchPath, RelativePath, RequestingModule,
[Preprocessor] Add a note with framework location for "file not found" error. When a framework with the same name is available at multiple framework search paths, we use the first matching location. If a framework at this location doesn't have all the headers, it can be confusing for developers because they see only an error `'Foo/Foo.h' file not found`, can find the complete framework with required header, and don't know the incomplete framework was used instead. Add a note explaining a framework without required header was found. Also mention framework directory path to make it easier to find the incomplete framework. rdar://problem/39246514 Reviewers: arphaman, erik.pilkington, jkorous Reviewed By: jkorous Subscribers: jkorous, dexonsmith, cfe-commits Differential Revision: https://reviews.llvm.org/D56561 llvm-svn: 353231
2019-02-06 06:34:55 +08:00
SuggestedModule, /*IsMapped=*/nullptr,
/*IsFrameworkFound=*/nullptr, SkipCache)) {
[modules] Add support for #include_next. #include_next interacts poorly with modules: it depends on where in the list of include paths the current file was found. Files covered by module maps are not found in include search paths when building the module (and are not found in include search paths when @importing the module either), so this isn't really meaningful. Instead, we fake up the result that #include_next *should* have given: find the first path that would have resulted in the given file being picked, and search from there onwards. llvm-svn: 220177
2014-10-20 08:15:49 +08:00
// Keep looking as if this file did a #include_next.
TmpFromDir = TmpCurDir;
++TmpFromDir;
if (FE == FromFile) {
// Found it.
FromDir = TmpFromDir;
CurDir = TmpCurDir;
break;
}
}
}
// Do a standard file entry lookup.
Add a 'RawPath' parameter to the PPCallbacks interface. This allows clients to observe the exact path through which an #included file was located. This is very useful when trying to record and replay inclusion operations without it beind influenced by the aggressive caching done inside the FileManager to avoid redundant system calls and filesystem operations. The work to compute and return this is only done in the presence of callbacks, so it should have no effect on normal compilation. Patch by Manuel Klimek. llvm-svn: 127742
2011-03-17 02:34:36 +08:00
const FileEntry *FE = HeaderInfo.LookupFile(
Implement MSVC header search algorithm in MicrosoftMode. Follows algorithm described here: http://msdn.microsoft.com/en-us/library/36k2cdd4.aspx llvm-svn: 198082
2013-12-28 03:46:16 +08:00
Filename, FilenameLoc, isAngled, FromDir, CurDir, Includers, SearchPath,
[Preprocessor] Add a note with framework location for "file not found" error. When a framework with the same name is available at multiple framework search paths, we use the first matching location. If a framework at this location doesn't have all the headers, it can be confusing for developers because they see only an error `'Foo/Foo.h' file not found`, can find the complete framework with required header, and don't know the incomplete framework was used instead. Add a note explaining a framework without required header was found. Also mention framework directory path to make it easier to find the incomplete framework. rdar://problem/39246514 Reviewers: arphaman, erik.pilkington, jkorous Reviewed By: jkorous Subscribers: jkorous, dexonsmith, cfe-commits Differential Revision: https://reviews.llvm.org/D56561 llvm-svn: 353231
2019-02-06 06:34:55 +08:00
RelativePath, RequestingModule, SuggestedModule, IsMapped,
IsFrameworkFound, SkipCache, BuildSystemModule);
This patch adds new private headers to the module map. Private headers may be included from within the module, but not from outside the module. llvm-svn: 184471
2013-06-21 05:14:14 +08:00
if (FE) {
Don't verify module inclusions in assembler files. llvm-svn: 203929
2014-03-14 22:53:17 +08:00
if (SuggestedModule && !LangOpts.AsmPreprocessor)
Enable layering check in unavailable modules. If a header file belonging to a certain module is not found on the filesystem, that header gets marked as unavailable. Now, the layering warning (-fmodules-decluse) should still warn about headers of this module being wrongfully included. Currently, headers belonging to those modules are just treated as not belonging to modules at all which means they can be included freely from everywhere. To implement this (somewhat) cleanly, I have moved most of the layering checks into the ModuleMap. This will also help with showing FixIts later. llvm-svn: 197805
2013-12-20 20:09:36 +08:00
HeaderInfo.getModuleMap().diagnoseHeaderInclusion(
[modules] Don't diagnose non-modular includes from modular files that are implementation units of modules rather than interface units. llvm-svn: 263449
2016-03-15 01:52:37 +08:00
RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc,
Filename, FE);
This patch adds new private headers to the module map. Private headers may be included from within the module, but not from outside the module. llvm-svn: 184471
2013-06-21 05:14:14 +08:00
return FE;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement MSVC header search algorithm in MicrosoftMode. Follows algorithm described here: http://msdn.microsoft.com/en-us/library/36k2cdd4.aspx llvm-svn: 198082
2013-12-28 03:46:16 +08:00
const FileEntry *CurFileEnt;
move PP::LookupFile from PPLexerChange -> PPDirectives.cpp llvm-svn: 48082
2008-03-09 12:17:44 +08:00
// Otherwise, see if this is a subframework header. If so, this is relative
// to one of the headers on the #include stack. Walk the list of the current
// headers on the #include stack and pass them to HeaderInfo.
Rename IsNonPragmaNonMacroLexer to IsFileLexer. llvm-svn: 59731
2008-11-21 00:19:53 +08:00
if (IsFileLexer()) {
Replace SM.getFileEntryForID(Lexer->getFileID()) with Lexer->getFileEntry(). llvm-svn: 255993
2015-12-18 18:30:12 +08:00
if ((CurFileEnt = CurPPLexer->getFileEntry())) {
Add a 'RawPath' parameter to the PPCallbacks interface. This allows clients to observe the exact path through which an #included file was located. This is very useful when trying to record and replay inclusion operations without it beind influenced by the aggressive caching done inside the FileManager to avoid redundant system calls and filesystem operations. The work to compute and return this is only done in the presence of callbacks, so it should have no effect on normal compilation. Patch by Manuel Klimek. llvm-svn: 127742
2011-03-17 02:34:36 +08:00
if ((FE = HeaderInfo.LookupSubframeworkHeader(Filename, CurFileEnt,
Teach subframework header lookup to suggest modules <rdar://problem/13176200>. llvm-svn: 174683
2013-02-08 08:10:48 +08:00
SearchPath, RelativePath,
Refactor module lookup when looking up a header file, and wire through the requesting module. No functionality change. llvm-svn: 250554
2015-10-17 05:42:56 +08:00
RequestingModule,
Add -Wnon-modular-include* options Warn on non-modular includes in various contexts. -Wnon-modular-include -Wnon-modular-include-in-module -Wnon-modular-include-in-framework-module Where each group is a subgroup of those above it. llvm-svn: 208004
2014-05-06 05:44:13 +08:00
SuggestedModule))) {
if (SuggestedModule && !LangOpts.AsmPreprocessor)
HeaderInfo.getModuleMap().diagnoseHeaderInclusion(
[modules] Don't diagnose non-modular includes from modular files that are implementation units of modules rather than interface units. llvm-svn: 263449
2016-03-15 01:52:37 +08:00
RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc,
Filename, FE);
move PP::LookupFile from PPLexerChange -> PPDirectives.cpp llvm-svn: 48082
2008-03-09 12:17:44 +08:00
return FE;
Add -Wnon-modular-include* options Warn on non-modular includes in various contexts. -Wnon-modular-include -Wnon-modular-include-in-module -Wnon-modular-include-in-framework-module Where each group is a subgroup of those above it. llvm-svn: 208004
2014-05-06 05:44:13 +08:00
}
}
move PP::LookupFile from PPLexerChange -> PPDirectives.cpp llvm-svn: 48082
2008-03-09 12:17:44 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[PP] Replace some uses of unsigned with size_t All values are returned by a method as size_t, and subsequently passed to functions taking a size_t, or used where a size_t is also valid. Better still, two loops (which had an unsigned), can be replaced by a range-based for loop. Differential Revision: http://reviews.llvm.org/D25939 llvm-svn: 285182
2016-10-26 17:58:31 +08:00
for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) {
Rename IsNonPragmaNonMacroLexer to IsFileLexer. llvm-svn: 59731
2008-11-21 00:19:53 +08:00
if (IsFileLexer(ISEntry)) {
Replace SM.getFileEntryForID(Lexer->getFileID()) with Lexer->getFileEntry(). llvm-svn: 255993
2015-12-18 18:30:12 +08:00
if ((CurFileEnt = ISEntry.ThePPLexer->getFileEntry())) {
To be able to replay compilations we need to accurately remodel how includes get resolved, especially when they are found relatively to another include file. We also try to get it working for framework includes, but that part of the code is untested, as I don't have a code base that uses it. llvm-svn: 130246
2011-04-27 05:50:03 +08:00
if ((FE = HeaderInfo.LookupSubframeworkHeader(
Teach subframework header lookup to suggest modules <rdar://problem/13176200>. llvm-svn: 174683
2013-02-08 08:10:48 +08:00
Filename, CurFileEnt, SearchPath, RelativePath,
Refactor module lookup when looking up a header file, and wire through the requesting module. No functionality change. llvm-svn: 250554
2015-10-17 05:42:56 +08:00
RequestingModule, SuggestedModule))) {
Add -Wnon-modular-include* options Warn on non-modular includes in various contexts. -Wnon-modular-include -Wnon-modular-include-in-module -Wnon-modular-include-in-framework-module Where each group is a subgroup of those above it. llvm-svn: 208004
2014-05-06 05:44:13 +08:00
if (SuggestedModule && !LangOpts.AsmPreprocessor)
HeaderInfo.getModuleMap().diagnoseHeaderInclusion(
[modules] Don't diagnose non-modular includes from modular files that are implementation units of modules rather than interface units. llvm-svn: 263449
2016-03-15 01:52:37 +08:00
RequestingModule, RequestingModuleIsModuleInterface,
FilenameLoc, Filename, FE);
move PP::LookupFile from PPLexerChange -> PPDirectives.cpp llvm-svn: 48082
2008-03-09 12:17:44 +08:00
return FE;
Add -Wnon-modular-include* options Warn on non-modular includes in various contexts. -Wnon-modular-include -Wnon-modular-include-in-module -Wnon-modular-include-in-framework-module Where each group is a subgroup of those above it. llvm-svn: 208004
2014-05-06 05:44:13 +08:00
}
}
move PP::LookupFile from PPLexerChange -> PPDirectives.cpp llvm-svn: 48082
2008-03-09 12:17:44 +08:00
}
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
move PP::LookupFile from PPLexerChange -> PPDirectives.cpp llvm-svn: 48082
2008-03-09 12:17:44 +08:00
// Otherwise, we really couldn't find the file.
[C++11] Use 'nullptr'. Lex edition. llvm-svn: 209083
2014-05-18 07:10:59 +08:00
return nullptr;
move PP::LookupFile from PPLexerChange -> PPDirectives.cpp llvm-svn: 48082
2008-03-09 12:17:44 +08:00
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
//===----------------------------------------------------------------------===//
// Preprocessor Directive Handling.
//===----------------------------------------------------------------------===//
Add a -rewrite-includes option, which is similar to -rewrite-macros, but only expands #include directives. Patch contributed by Lubos Lunak (l.lunax@suse.cz). Review by Matt Beaumont-Gay (matthewbg@google.com). llvm-svn: 158093
2012-06-07 02:52:13 +08:00
class Preprocessor::ResetMacroExpansionHelper {
public:
ResetMacroExpansionHelper(Preprocessor *pp)
: PP(pp), save(pp->DisableMacroExpansion) {
if (pp->MacroExpansionInDirectivesOverride)
pp->DisableMacroExpansion = false;
}
Fix remaining Clang-tidy readability-redundant-control-flow warnings; other minor fixes. Differential revision: http://reviews.llvm.org/D17218 llvm-svn: 260757
2016-02-13 06:53:10 +08:00
Add a -rewrite-includes option, which is similar to -rewrite-macros, but only expands #include directives. Patch contributed by Lubos Lunak (l.lunax@suse.cz). Review by Matt Beaumont-Gay (matthewbg@google.com). llvm-svn: 158093
2012-06-07 02:52:13 +08:00
~ResetMacroExpansionHelper() {
PP->DisableMacroExpansion = save;
}
Fix remaining Clang-tidy readability-redundant-control-flow warnings; other minor fixes. Differential revision: http://reviews.llvm.org/D17218 llvm-svn: 260757
2016-02-13 06:53:10 +08:00
Add a -rewrite-includes option, which is similar to -rewrite-macros, but only expands #include directives. Patch contributed by Lubos Lunak (l.lunax@suse.cz). Review by Matt Beaumont-Gay (matthewbg@google.com). llvm-svn: 158093
2012-06-07 02:52:13 +08:00
private:
Preprocessor *PP;
bool save;
};
[clang-cl, PCH] Support for /Yc and /Yu without filename and #pragma hdrstop With clang-cl, when the user specifies /Yc or /Yu without a filename the compiler uses a #pragma hdrstop in the main source file to determine the end of the PCH. If a header is specified with /Yc or /Yu #pragma hdrstop has no effect. The optional #pragma hdrstop filename argument is not yet supported. Differential Revision: https://reviews.llvm.org/D51391 llvm-svn: 341963
2018-09-12 01:10:44 +08:00
/// Process a directive while looking for the through header or a #pragma
/// hdrstop. The following directives are handled:
/// #include (to check if it is the through header)
/// #define (to warn about macros that don't match the PCH)
/// #pragma (to check for pragma hdrstop).
/// All other directives are completely discarded.
void Preprocessor::HandleSkippedDirectiveWhileUsingPCH(Token &Result,
[clang-cl, PCH] Implement support for MS-style PCH through headers Implement support for MS-style PCH through headers. This enables support for /Yc and /Yu where the through header is either on the command line or included in the source. It replaces the current support the requires the header also be specified with /FI. This change adds a -cc1 option -pch-through-header that is used to either start or stop compilation during PCH create or use. When creating a PCH, the compilation ends after compilation of the through header. When using a PCH, tokens are skipped until after the through header is seen. Patch By: mikerice Differential Revision: https://reviews.llvm.org/D46652 llvm-svn: 336379
2018-07-06 01:22:13 +08:00
SourceLocation HashLoc) {
if (const IdentifierInfo *II = Result.getIdentifierInfo()) {
[clang-cl, PCH] Support for /Yc and /Yu without filename and #pragma hdrstop With clang-cl, when the user specifies /Yc or /Yu without a filename the compiler uses a #pragma hdrstop in the main source file to determine the end of the PCH. If a header is specified with /Yc or /Yu #pragma hdrstop has no effect. The optional #pragma hdrstop filename argument is not yet supported. Differential Revision: https://reviews.llvm.org/D51391 llvm-svn: 341963
2018-09-12 01:10:44 +08:00
if (II->getPPKeywordID() == tok::pp_define) {
[clang-cl, PCH] Implement support for MS-style PCH through headers Implement support for MS-style PCH through headers. This enables support for /Yc and /Yu where the through header is either on the command line or included in the source. It replaces the current support the requires the header also be specified with /FI. This change adds a -cc1 option -pch-through-header that is used to either start or stop compilation during PCH create or use. When creating a PCH, the compilation ends after compilation of the through header. When using a PCH, tokens are skipped until after the through header is seen. Patch By: mikerice Differential Revision: https://reviews.llvm.org/D46652 llvm-svn: 336379
2018-07-06 01:22:13 +08:00
return HandleDefineDirective(Result,
/*ImmediatelyAfterHeaderGuard=*/false);
[clang-cl, PCH] Support for /Yc and /Yu without filename and #pragma hdrstop With clang-cl, when the user specifies /Yc or /Yu without a filename the compiler uses a #pragma hdrstop in the main source file to determine the end of the PCH. If a header is specified with /Yc or /Yu #pragma hdrstop has no effect. The optional #pragma hdrstop filename argument is not yet supported. Differential Revision: https://reviews.llvm.org/D51391 llvm-svn: 341963
2018-09-12 01:10:44 +08:00
}
if (SkippingUntilPCHThroughHeader &&
II->getPPKeywordID() == tok::pp_include) {
return HandleIncludeDirective(HashLoc, Result);
}
if (SkippingUntilPragmaHdrStop && II->getPPKeywordID() == tok::pp_pragma) {
Remove use of lookahead from _Pragma handling and from all other internal lexing steps in the preprocessor. It is not safe to use the preprocessor's token lookahead except when operating on the final sequence of tokens that would be produced by phase 4 of translation. Doing so corrupts the token lookahead cache used by the parser. (See added testcase for an example.) Lookahead should instead be viewed as a layer on top of the normal lexer. Added assertions to catch any further incorrect uses of lookahead within lexing actions. llvm-svn: 358230
2019-04-12 05:18:22 +08:00
Lex(Result);
auto *II = Result.getIdentifierInfo();
[clang-cl, PCH] Support for /Yc and /Yu without filename and #pragma hdrstop With clang-cl, when the user specifies /Yc or /Yu without a filename the compiler uses a #pragma hdrstop in the main source file to determine the end of the PCH. If a header is specified with /Yc or /Yu #pragma hdrstop has no effect. The optional #pragma hdrstop filename argument is not yet supported. Differential Revision: https://reviews.llvm.org/D51391 llvm-svn: 341963
2018-09-12 01:10:44 +08:00
if (II && II->getName() == "hdrstop")
Remove use of lookahead from _Pragma handling and from all other internal lexing steps in the preprocessor. It is not safe to use the preprocessor's token lookahead except when operating on the final sequence of tokens that would be produced by phase 4 of translation. Doing so corrupts the token lookahead cache used by the parser. (See added testcase for an example.) Lookahead should instead be viewed as a layer on top of the normal lexer. Added assertions to catch any further incorrect uses of lookahead within lexing actions. llvm-svn: 358230
2019-04-12 05:18:22 +08:00
return HandlePragmaHdrstop(Result);
[clang-cl, PCH] Support for /Yc and /Yu without filename and #pragma hdrstop With clang-cl, when the user specifies /Yc or /Yu without a filename the compiler uses a #pragma hdrstop in the main source file to determine the end of the PCH. If a header is specified with /Yc or /Yu #pragma hdrstop has no effect. The optional #pragma hdrstop filename argument is not yet supported. Differential Revision: https://reviews.llvm.org/D51391 llvm-svn: 341963
2018-09-12 01:10:44 +08:00
}
[clang-cl, PCH] Implement support for MS-style PCH through headers Implement support for MS-style PCH through headers. This enables support for /Yc and /Yu where the through header is either on the command line or included in the source. It replaces the current support the requires the header also be specified with /FI. This change adds a -cc1 option -pch-through-header that is used to either start or stop compilation during PCH create or use. When creating a PCH, the compilation ends after compilation of the through header. When using a PCH, tokens are skipped until after the through header is seen. Patch By: mikerice Differential Revision: https://reviews.llvm.org/D46652 llvm-svn: 336379
2018-07-06 01:22:13 +08:00
}
DiscardUntilEndOfDirective();
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
/// HandleDirective - This callback is invoked when the lexer sees a # token
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
/// at the start of a line. This consumes the directive, modifies the
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
/// lexer/preprocessor state, and advances the lexer(s) so that the next token
/// read is the correct one.
void Preprocessor::HandleDirective(Token &Result) {
// FIXME: Traditional: # with whitespace before it not recognized by K&R?
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// We just parsed a # character at the start of a line, so we're in directive
// mode. Tell the lexer this so any newlines we see will be converted into an
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
// EOD token (which terminates the directive).
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
CurPPLexer->ParsingPreprocessorDirective = true;
Preprocessor: preserve whitespace in -traditional-cpp mode. Note that unlike GNU cpp we currently do not preserve whitespace in macros (even in -traditional-cpp mode). <rdar://problem/12897179> llvm-svn: 175778
2013-02-22 02:53:19 +08:00
if (CurLexer) CurLexer->SetKeepWhitespaceMode(false);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introducing -Wheader-guard, a warning that checks header guards actually work properly. This warning checks that the #ifndef and #define directives at the beginning of a header refer to the same macro name. Includes a fix-it hint to correct the header guard. llvm-svn: 183867
2013-06-13 05:20:57 +08:00
bool ImmediatelyAfterTopLevelIfndef =
CurPPLexer->MIOpt.getImmediatelyAfterTopLevelIfndef();
CurPPLexer->MIOpt.resetImmediatelyAfterTopLevelIfndef();
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
++NumDirectives;
Use SmallString instead of SmallVector llvm-svn: 98436
2010-03-13 18:17:05 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// We are about to read a token. For the multiple-include optimization FA to
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// work, we have to remember if we had read any tokens *before* this
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// pp-directive.
formatting changes. llvm-svn: 91263
2009-12-14 12:54:40 +08:00
bool ReadAnyTokensBeforeDirective =CurPPLexer->MIOpt.getHasReadAnyTokensVal();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
when preprocessing a .S file, unknown directives should just be passed through, and the token after the # should be expanded if it is not a valid directive. This allows us to transform things like: #define FOO BAR # FOO into # BAR, even though FOO is not normally expanded for directives. This should fix PR3833 llvm-svn: 67236
2009-03-19 05:00:25 +08:00
// Save the '#' token in case we need to return it later.
Token SavedHash = Result;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Read the next token, the directive flavor. This isn't expanded due to
// C99 6.10.3p8.
LexUnexpandedToken(Result);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// C99 6.10.3p11: Is this preprocessor directive in macro invocation? e.g.:
// #define A(x) #x
// A(abc
// #warning blah
// def)
Don't allow #include (and its friends #import, #include_next and #__include_macros) in the arguments of a function-style macro. Directives in the arguments of such macros have undefined behaviour, and GCC does not correctly support these cases. In some situations, this can lead to better diagnostics. llvm-svn: 146765
2011-12-17 06:50:01 +08:00
// If so, the user is relying on undefined behavior, emit a diagnostic. Do
// not support this for #include-like directives, since that can result in
// terrible diagnostics, and does not work in GCC.
if (InMacroArgs) {
if (IdentifierInfo *II = Result.getIdentifierInfo()) {
switch (II->getPPKeywordID()) {
case tok::pp_include:
case tok::pp_import:
case tok::pp_include_next:
case tok::pp___include_macros:
Lex: Don't let annotation tokens get into macro expansion We'd let annotation tokens from '#pragma pack' and the like get inside a function-like macro. This would lead to terror and mayhem; stop the madness early. This fixes PR22037. llvm-svn: 224896
2014-12-28 15:42:49 +08:00
case tok::pp_pragma:
Diag(Result, diag::err_embedded_directive) << II->getName();
Print a note to the called macro when diagnosing err_embedded_directive Fixes PR40713, see there for the motivation for this. Differential Revision: https://reviews.llvm.org/D58161 llvm-svn: 354009
2019-02-14 12:13:17 +08:00
Diag(*ArgMacro, diag::note_macro_expansion_here)
<< ArgMacro->getIdentifierInfo();
Don't allow #include (and its friends #import, #include_next and #__include_macros) in the arguments of a function-style macro. Directives in the arguments of such macros have undefined behaviour, and GCC does not correctly support these cases. In some situations, this can lead to better diagnostics. llvm-svn: 146765
2011-12-17 06:50:01 +08:00
DiscardUntilEndOfDirective();
return;
default:
break;
}
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Diag(Result, diag::ext_embedded_directive);
Don't allow #include (and its friends #import, #include_next and #__include_macros) in the arguments of a function-style macro. Directives in the arguments of such macros have undefined behaviour, and GCC does not correctly support these cases. In some situations, this can lead to better diagnostics. llvm-svn: 146765
2011-12-17 06:50:01 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Add a -rewrite-includes option, which is similar to -rewrite-macros, but only expands #include directives. Patch contributed by Lubos Lunak (l.lunax@suse.cz). Review by Matt Beaumont-Gay (matthewbg@google.com). llvm-svn: 158093
2012-06-07 02:52:13 +08:00
// Temporarily enable macro expansion if set so
// and reset to previous state when returning from this function.
ResetMacroExpansionHelper helper(this);
[clang-cl, PCH] Support for /Yc and /Yu without filename and #pragma hdrstop With clang-cl, when the user specifies /Yc or /Yu without a filename the compiler uses a #pragma hdrstop in the main source file to determine the end of the PCH. If a header is specified with /Yc or /Yu #pragma hdrstop has no effect. The optional #pragma hdrstop filename argument is not yet supported. Differential Revision: https://reviews.llvm.org/D51391 llvm-svn: 341963
2018-09-12 01:10:44 +08:00
if (SkippingUntilPCHThroughHeader || SkippingUntilPragmaHdrStop)
return HandleSkippedDirectiveWhileUsingPCH(Result, SavedHash.getLocation());
[clang-cl, PCH] Implement support for MS-style PCH through headers Implement support for MS-style PCH through headers. This enables support for /Yc and /Yu where the through header is either on the command line or included in the source. It replaces the current support the requires the header also be specified with /FI. This change adds a -cc1 option -pch-through-header that is used to either start or stop compilation during PCH create or use. When creating a PCH, the compilation ends after compilation of the through header. When using a PCH, tokens are skipped until after the through header is seen. Patch By: mikerice Differential Revision: https://reviews.llvm.org/D46652 llvm-svn: 336379
2018-07-06 01:22:13 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
switch (Result.getKind()) {
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
case tok::eod:
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
return; // null directive.
Introduce basic code-completion support for preprocessor directives, e.g., after a "#" we'll suggest #if, #ifdef, etc. llvm-svn: 111943
2010-08-25 03:08:16 +08:00
case tok::code_completion:
if (CodeComplete)
CodeComplete->CodeCompleteDirective(
CurPPLexer->getConditionalStackDepth() > 0);
Support code-completion for C++ inline methods and ObjC buffering methods. Previously we would cut off the source file buffer at the code-completion point; this impeded code-completion inside C++ inline methods and, recently, with buffering ObjC methods. Have the code-completion inserted into the source buffer so that it can be buffered along with a method body. When we actually hit the code-completion point the cut-off lexing or parsing. Fixes rdar://10056932&8319466 llvm-svn: 139086
2011-09-04 11:32:15 +08:00
setCodeCompletionReached();
Introduce basic code-completion support for preprocessor directives, e.g., after a "#" we'll suggest #if, #ifdef, etc. llvm-svn: 111943
2010-08-25 03:08:16 +08:00
return;
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
case tok::numeric_constant: // # 7 GNU line marker directive.
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (getLangOpts().AsmPreprocessor)
This is not considered a preprocessor directive in .S files: # 4 llvm-svn: 67233
2009-03-19 04:41:10 +08:00
break; // # 4 is not a preprocessor directive in .S files.
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
return HandleDigitDirective(Result);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
default:
IdentifierInfo *II = Result.getIdentifierInfo();
[C++11] Use 'nullptr'. Lex edition. llvm-svn: 209083
2014-05-18 07:10:59 +08:00
if (!II) break; // Not an identifier.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Ask what the preprocessor keyword ID is.
switch (II->getPPKeywordID()) {
default: break;
// C99 6.10.1 - Conditional Inclusion.
case tok::pp_if:
[Lexer] Report more precise skipped regions (PR34166) This patch teaches the preprocessor to report more precise source ranges for code that is skipped due to conditional directives. The new behavior includes the '#' from the opening directive and the full text of the line containing the closing directive in the skipped area. This matches up clang's behavior (we don't IRGen the code between the closing "endif" and the end of a line). This also affects the code coverage implementation. See llvm.org/PR34166 (this also happens to be rdar://problem/23224058). The old behavior (report the end of the skipped range as the end location of the 'endif' token) is preserved for indexing clients. Differential Revision: https://reviews.llvm.org/D36642 llvm-svn: 312947
2017-09-12 04:47:42 +08:00
return HandleIfDirective(Result, SavedHash, ReadAnyTokensBeforeDirective);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
case tok::pp_ifdef:
[Lexer] Report more precise skipped regions (PR34166) This patch teaches the preprocessor to report more precise source ranges for code that is skipped due to conditional directives. The new behavior includes the '#' from the opening directive and the full text of the line containing the closing directive in the skipped area. This matches up clang's behavior (we don't IRGen the code between the closing "endif" and the end of a line). This also affects the code coverage implementation. See llvm.org/PR34166 (this also happens to be rdar://problem/23224058). The old behavior (report the end of the skipped range as the end location of the 'endif' token) is preserved for indexing clients. Differential Revision: https://reviews.llvm.org/D36642 llvm-svn: 312947
2017-09-12 04:47:42 +08:00
return HandleIfdefDirective(Result, SavedHash, false,
true /*not valid for miopt*/);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
case tok::pp_ifndef:
[Lexer] Report more precise skipped regions (PR34166) This patch teaches the preprocessor to report more precise source ranges for code that is skipped due to conditional directives. The new behavior includes the '#' from the opening directive and the full text of the line containing the closing directive in the skipped area. This matches up clang's behavior (we don't IRGen the code between the closing "endif" and the end of a line). This also affects the code coverage implementation. See llvm.org/PR34166 (this also happens to be rdar://problem/23224058). The old behavior (report the end of the skipped range as the end location of the 'endif' token) is preserved for indexing clients. Differential Revision: https://reviews.llvm.org/D36642 llvm-svn: 312947
2017-09-12 04:47:42 +08:00
return HandleIfdefDirective(Result, SavedHash, true,
ReadAnyTokensBeforeDirective);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
case tok::pp_elif:
[Lexer] Report more precise skipped regions (PR34166) This patch teaches the preprocessor to report more precise source ranges for code that is skipped due to conditional directives. The new behavior includes the '#' from the opening directive and the full text of the line containing the closing directive in the skipped area. This matches up clang's behavior (we don't IRGen the code between the closing "endif" and the end of a line). This also affects the code coverage implementation. See llvm.org/PR34166 (this also happens to be rdar://problem/23224058). The old behavior (report the end of the skipped range as the end location of the 'endif' token) is preserved for indexing clients. Differential Revision: https://reviews.llvm.org/D36642 llvm-svn: 312947
2017-09-12 04:47:42 +08:00
return HandleElifDirective(Result, SavedHash);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
case tok::pp_else:
[Lexer] Report more precise skipped regions (PR34166) This patch teaches the preprocessor to report more precise source ranges for code that is skipped due to conditional directives. The new behavior includes the '#' from the opening directive and the full text of the line containing the closing directive in the skipped area. This matches up clang's behavior (we don't IRGen the code between the closing "endif" and the end of a line). This also affects the code coverage implementation. See llvm.org/PR34166 (this also happens to be rdar://problem/23224058). The old behavior (report the end of the skipped range as the end location of the 'endif' token) is preserved for indexing clients. Differential Revision: https://reviews.llvm.org/D36642 llvm-svn: 312947
2017-09-12 04:47:42 +08:00
return HandleElseDirective(Result, SavedHash);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
case tok::pp_endif:
return HandleEndifDirective(Result);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// C99 6.10.2 - Source File Inclusion.
case tok::pp_include:
Extend the preprocessing record and libclang with support for inclusion directives, keeping track of every #include, #import, etc. in the translation unit. We keep track of the source location and kind of the inclusion, how the file name was spelled, and the underlying file to which the inclusion resolved. llvm-svn: 116952
2010-10-21 06:00:55 +08:00
// Handle #include.
return HandleIncludeDirective(SavedHash.getLocation(), Result);
Add initial support for -imacros. Right now it has the same semantics as -include, but that will be fixed soon. llvm-svn: 68625
2009-04-09 02:24:34 +08:00
case tok::pp___include_macros:
Extend the preprocessing record and libclang with support for inclusion directives, keeping track of every #include, #import, etc. in the translation unit. We keep track of the source location and kind of the inclusion, how the file name was spelled, and the underlying file to which the inclusion resolved. llvm-svn: 116952
2010-10-21 06:00:55 +08:00
// Handle -imacros.
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
return HandleIncludeMacrosDirective(SavedHash.getLocation(), Result);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// C99 6.10.3 - Macro Replacement.
case tok::pp_define:
Introducing -Wheader-guard, a warning that checks header guards actually work properly. This warning checks that the #ifndef and #define directives at the beginning of a header refer to the same macro name. Includes a fix-it hint to correct the header guard. llvm-svn: 183867
2013-06-13 05:20:57 +08:00
return HandleDefineDirective(Result, ImmediatelyAfterTopLevelIfndef);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
case tok::pp_undef:
PP: Remove unused parameters from methods NFC Differential Revision: http://reviews.llvm.org/D25938 llvm-svn: 285180
2016-10-26 16:52:41 +08:00
return HandleUndefDirective();
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// C99 6.10.4 - Line Control.
case tok::pp_line:
PP: Remove unused parameters from methods NFC Differential Revision: http://reviews.llvm.org/D25938 llvm-svn: 285180
2016-10-26 16:52:41 +08:00
return HandleLineDirective();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// C99 6.10.5 - Error Directive.
case tok::pp_error:
return HandleUserDiagnosticDirective(Result, false);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// C99 6.10.6 - Pragma Directive.
case tok::pp_pragma:
Added preproc callback for pragma directives. llvm-svn: 186770
2013-07-21 04:09:11 +08:00
return HandlePragmaDirective(SavedHash.getLocation(), PIK_HashPragma);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// GNU Extensions.
case tok::pp_import:
Extend the preprocessing record and libclang with support for inclusion directives, keeping track of every #include, #import, etc. in the translation unit. We keep track of the source location and kind of the inclusion, how the file name was spelled, and the underlying file to which the inclusion resolved. llvm-svn: 116952
2010-10-21 06:00:55 +08:00
return HandleImportDirective(SavedHash.getLocation(), Result);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
case tok::pp_include_next:
Extend the preprocessing record and libclang with support for inclusion directives, keeping track of every #include, #import, etc. in the translation unit. We keep track of the source location and kind of the inclusion, how the file name was spelled, and the underlying file to which the inclusion resolved. llvm-svn: 116952
2010-10-21 06:00:55 +08:00
return HandleIncludeNextDirective(SavedHash.getLocation(), Result);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
case tok::pp_warning:
Diag(Result, diag::ext_pp_warning_directive);
return HandleUserDiagnosticDirective(Result, true);
case tok::pp_ident:
return HandleIdentSCCSDirective(Result);
case tok::pp_sccs:
return HandleIdentSCCSDirective(Result);
case tok::pp_assert:
//isExtension = true; // FIXME: implement #assert
break;
case tok::pp_unassert:
//isExtension = true; // FIXME: implement #unassert
break;
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
Re-uglify #public and #private to #__public_macro and #__private_macro. llvm-svn: 147469
2012-01-04 03:48:16 +08:00
case tok::pp___public_macro:
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (getLangOpts().Modules)
Under -fmodules, accept #public <macroname> and #private <macroname> to make a macro public (the default for headers) or private, respectively. llvm-svn: 147455
2012-01-04 02:24:14 +08:00
return HandleMacroPublicDirective(Result);
break;
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
Re-uglify #public and #private to #__public_macro and #__private_macro. llvm-svn: 147469
2012-01-04 03:48:16 +08:00
case tok::pp___private_macro:
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (getLangOpts().Modules)
PP: Remove unused parameters from methods NFC Differential Revision: http://reviews.llvm.org/D25938 llvm-svn: 285180
2016-10-26 16:52:41 +08:00
return HandleMacroPrivateDirective();
Under -fmodules, accept #public <macroname> and #private <macroname> to make a macro public (the default for headers) or private, respectively. llvm-svn: 147455
2012-01-04 02:24:14 +08:00
break;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
break;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
when preprocessing a .S file, unknown directives should just be passed through, and the token after the # should be expanded if it is not a valid directive. This allows us to transform things like: #define FOO BAR # FOO into # BAR, even though FOO is not normally expanded for directives. This should fix PR3833 llvm-svn: 67236
2009-03-19 05:00:25 +08:00
// If this is a .S file, treat unknown # directives as non-preprocessor
// directives. This is important because # may be a comment or introduce
// various pseudo-ops. Just return the # token and push back the following
// token to be lexed next time.
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (getLangOpts().AsmPreprocessor) {
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
auto Toks = llvm::make_unique<Token[]>(2);
when preprocessing a .S file, unknown directives should just be passed through, and the token after the # should be expanded if it is not a valid directive. This allows us to transform things like: #define FOO BAR # FOO into # BAR, even though FOO is not normally expanded for directives. This should fix PR3833 llvm-svn: 67236
2009-03-19 05:00:25 +08:00
// Return the # and the token after it.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Toks[0] = SavedHash;
when preprocessing a .S file, unknown directives should just be passed through, and the token after the # should be expanded if it is not a valid directive. This allows us to transform things like: #define FOO BAR # FOO into # BAR, even though FOO is not normally expanded for directives. This should fix PR3833 llvm-svn: 67236
2009-03-19 05:00:25 +08:00
Toks[1] = Result;
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
fix rdar://8823139, a crash on a comment in a preprocessed .s file that contains the ## operator. llvm-svn: 122946
2011-01-06 13:01:51 +08:00
// If the second token is a hashhash token, then we need to translate it to
// unknown so the token lexer doesn't try to perform token pasting.
if (Result.is(tok::hashhash))
Toks[1].setKind(tok::unknown);
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
when preprocessing a .S file, unknown directives should just be passed through, and the token after the # should be expanded if it is not a valid directive. This allows us to transform things like: #define FOO BAR # FOO into # BAR, even though FOO is not normally expanded for directives. This should fix PR3833 llvm-svn: 67236
2009-03-19 05:00:25 +08:00
// Enter this token stream so that we re-lex the tokens. Make sure to
// enable macro expansion, in case the token after the # is an identifier
// that is expanded.
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
EnterTokenStream(std::move(Toks), 2, false);
when preprocessing a .S file, unknown directives should just be passed through, and the token after the # should be expanded if it is not a valid directive. This allows us to transform things like: #define FOO BAR # FOO into # BAR, even though FOO is not normally expanded for directives. This should fix PR3833 llvm-svn: 67236
2009-03-19 05:00:25 +08:00
return;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// If we reached here, the preprocessing token is not valid!
Diag(Result, diag::err_pp_invalid_directive);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Read the rest of the PP line.
DiscardUntilEndOfDirective();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Okay, we're done parsing the directive.
}
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
/// GetLineValue - Convert a numeric token into an unsigned value, emitting
/// Diagnostic DiagID if it is invalid, and returning the value in Val.
static bool GetLineValue(Token &DigitTok, unsigned &Val,
Improve the diagnostics of the number-reading preprocessor directives. The GNU line marker directive was sharing code with the #line directive, but some of the warnings/errors were reporting as #line directive diagnostics in both cases. Previously: #line 11foo1 ==> "#line directive requires a simple digit sequence" # 11foo1 ==> "#line directive requires a simple digit sequence" Now, we get: #line 11foo1 ==> "#line directive requires a simple digit sequence" # 11foo1 ==> "GNU line marker directive requires a simple digit sequence" llvm-svn: 179139
2013-04-10 09:04:18 +08:00
unsigned DiagID, Preprocessor &PP,
bool IsGNULineDirective=false) {
parse and enforce required constraints on #line directives. Right now we just discard them. llvm-svn: 62999
2009-01-26 13:29:08 +08:00
if (DigitTok.isNot(tok::numeric_constant)) {
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
PP.Diag(DigitTok, DiagID);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
if (DigitTok.isNot(tok::eod))
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
PP.DiscardUntilEndOfDirective();
return true;
parse and enforce required constraints on #line directives. Right now we just discard them. llvm-svn: 62999
2009-01-26 13:29:08 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Basic: import SmallString<> into clang namespace (I was going to fix the TODO about DenseMap too, but that would break self-host right now. See PR11922.) llvm-svn: 149799
2012-02-05 10:13:05 +08:00
SmallString<64> IntegerBuffer;
parse and enforce required constraints on #line directives. Right now we just discard them. llvm-svn: 62999
2009-01-26 13:29:08 +08:00
IntegerBuffer.resize(DigitTok.getLength());
const char *DigitTokBegin = &IntegerBuffer[0];
Audit all Preprocessor::getSpelling() callers, improving failure recovery for those that need it. llvm-svn: 98689
2010-03-17 06:30:13 +08:00
bool Invalid = false;
unsigned ActualLength = PP.getSpelling(DigitTok, DigitTokBegin, &Invalid);
if (Invalid)
return true;
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
more fun with line markers: the digit string is required to be interpreted as decimal, even if it starts with 0. Also, since things like 0x1 are completely illegal, don't even bother using numericliteralparser for them. llvm-svn: 69454
2009-04-19 02:35:15 +08:00
// Verify that we have a simple digit-sequence, and compute the value. This
// is always a simple digit string computed in decimal, so we do this manually
// here.
Val = 0;
for (unsigned i = 0; i != ActualLength; ++i) {
Per updates to D3781, allow underscore under ' in a pp-number, and allow ' in a #line directive. llvm-svn: 191443
2013-09-27 02:13:20 +08:00
// C++1y [lex.fcon]p1:
// Optional separating single quotes in a digit-sequence are ignored
if (DigitTokBegin[i] == '\'')
continue;
Excise <cctype> from Clang (except clang-tblgen) in favor of CharInfo.h. Nearly all of these changes are one-to-one replacements; the few that aren't have to do with custom identifier validation. llvm-svn: 174768
2013-02-09 06:30:41 +08:00
if (!isDigit(DigitTokBegin[i])) {
more fun with line markers: the digit string is required to be interpreted as decimal, even if it starts with 0. Also, since things like 0x1 are completely illegal, don't even bother using numericliteralparser for them. llvm-svn: 69454
2009-04-19 02:35:15 +08:00
PP.Diag(PP.AdvanceToTokenCharacter(DigitTok.getLocation(), i),
Improve the diagnostics of the number-reading preprocessor directives. The GNU line marker directive was sharing code with the #line directive, but some of the warnings/errors were reporting as #line directive diagnostics in both cases. Previously: #line 11foo1 ==> "#line directive requires a simple digit sequence" # 11foo1 ==> "#line directive requires a simple digit sequence" Now, we get: #line 11foo1 ==> "#line directive requires a simple digit sequence" # 11foo1 ==> "GNU line marker directive requires a simple digit sequence" llvm-svn: 179139
2013-04-10 09:04:18 +08:00
diag::err_pp_line_digit_sequence) << IsGNULineDirective;
more fun with line markers: the digit string is required to be interpreted as decimal, even if it starts with 0. Also, since things like 0x1 are completely illegal, don't even bother using numericliteralparser for them. llvm-svn: 69454
2009-04-19 02:35:15 +08:00
PP.DiscardUntilEndOfDirective();
return true;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
more fun with line markers: the digit string is required to be interpreted as decimal, even if it starts with 0. Also, since things like 0x1 are completely illegal, don't even bother using numericliteralparser for them. llvm-svn: 69454
2009-04-19 02:35:15 +08:00
unsigned NextVal = Val*10+(DigitTokBegin[i]-'0');
if (NextVal < Val) { // overflow.
PP.Diag(DigitTok, DiagID);
PP.DiscardUntilEndOfDirective();
return true;
}
Val = NextVal;
parse and enforce required constraints on #line directives. Right now we just discard them. llvm-svn: 62999
2009-01-26 13:29:08 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
preprocessing: gcc supports #line 0. So, treat this as a gcc supported extension with usual treatment with -pedantic (warn) and -pedantic-errors (error). // rdar://11550996 llvm-svn: 159226
2012-06-27 05:19:20 +08:00
if (DigitTokBegin[0] == '0' && Val)
Improve the diagnostics of the number-reading preprocessor directives. The GNU line marker directive was sharing code with the #line directive, but some of the warnings/errors were reporting as #line directive diagnostics in both cases. Previously: #line 11foo1 ==> "#line directive requires a simple digit sequence" # 11foo1 ==> "#line directive requires a simple digit sequence" Now, we get: #line 11foo1 ==> "#line directive requires a simple digit sequence" # 11foo1 ==> "GNU line marker directive requires a simple digit sequence" llvm-svn: 179139
2013-04-10 09:04:18 +08:00
PP.Diag(DigitTok.getLocation(), diag::warn_pp_line_decimal)
<< IsGNULineDirective;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
return false;
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Handle a \#line directive: C99 6.10.4.
Documentation cleanup: * Add \brief summaries; * Escape # characters in Doxygen comments; * Add \code...\endcode markup for code examples; * Add \verbatim...\endverbatim markup for grammar productions. llvm-svn: 158976
2012-06-22 13:46:07 +08:00
///
/// The two acceptable forms are:
/// \verbatim
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
/// # line digit-sequence
/// # line digit-sequence "s-char-sequence"
Documentation cleanup: * Add \brief summaries; * Escape # characters in Doxygen comments; * Add \code...\endcode markup for code examples; * Add \verbatim...\endverbatim markup for grammar productions. llvm-svn: 158976
2012-06-22 13:46:07 +08:00
/// \endverbatim
PP: Remove unused parameters from methods NFC Differential Revision: http://reviews.llvm.org/D25938 llvm-svn: 285180
2016-10-26 16:52:41 +08:00
void Preprocessor::HandleLineDirective() {
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
// Read the line # and string argument. Per C99 6.10.4p5, these tokens are
// expanded.
Token DigitTok;
Lex(DigitTok);
// Validate the number and convert it to an unsigned.
unsigned LineNo;
more fun with line markers: the digit string is required to be interpreted as decimal, even if it starts with 0. Also, since things like 0x1 are completely illegal, don't even bother using numericliteralparser for them. llvm-svn: 69454
2009-04-19 02:35:15 +08:00
if (GetLineValue(DigitTok, LineNo, diag::err_pp_line_requires_integer,*this))
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
return;
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
preprocessing: gcc supports #line 0. So, treat this as a gcc supported extension with usual treatment with -pedantic (warn) and -pedantic-errors (error). // rdar://11550996 llvm-svn: 159226
2012-06-27 05:19:20 +08:00
if (LineNo == 0)
Diag(DigitTok, diag::ext_pp_line_zero);
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
// Enforce C99 6.10.4p3: "The digit sequence shall not specify ... a
// number greater than 2147483647". C90 requires that the line # be <= 32767.
A couple random preprocessor changes that got ported from C99 to C++11. llvm-svn: 141596
2011-10-11 07:35:28 +08:00
unsigned LineLimit = 32768U;
s/CPlusPlus0x/CPlusPlus11/g llvm-svn: 171367
2013-01-02 19:42:31 +08:00
if (LangOpts.C99 || LangOpts.CPlusPlus11)
A couple random preprocessor changes that got ported from C99 to C++11. llvm-svn: 141596
2011-10-11 07:35:28 +08:00
LineLimit = 2147483648U;
parse and enforce required constraints on #line directives. Right now we just discard them. llvm-svn: 62999
2009-01-26 13:29:08 +08:00
if (LineNo >= LineLimit)
Diag(DigitTok, diag::ext_pp_line_too_big) << LineLimit;
s/CPlusPlus0x/CPlusPlus11/g llvm-svn: 171367
2013-01-02 19:42:31 +08:00
else if (LangOpts.CPlusPlus11 && LineNo >= 32768U)
-Wc++98-compat warnings for the lexer. This also adds a -Wc++98-compat-pedantic for warning on constructs which would be diagnosed by -std=c++98 -pedantic (that is, it warns even on C++11 features which we enable by default, with no warning, in C++98 mode). llvm-svn: 142034
2011-10-15 09:18:56 +08:00
Diag(DigitTok, diag::warn_cxx98_compat_pp_line_too_big);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
start plumbing together the line table information. So far we just unique the Filenames in #line directives, assigning them UIDs. llvm-svn: 63010
2009-01-26 15:57:50 +08:00
int FilenameID = -1;
parse and enforce required constraints on #line directives. Right now we just discard them. llvm-svn: 62999
2009-01-26 13:29:08 +08:00
Token StrTok;
Lex(StrTok);
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
// If the StrTok is "eod", then it wasn't present. Otherwise, it must be a
// string followed by eod.
if (StrTok.is(tok::eod))
Remove random windows line endings that snuck into the middle of this code. llvm-svn: 351633
2019-01-19 14:36:00 +08:00
; // ok
else if (StrTok.isNot(tok::string_literal)) {
Diag(StrTok, diag::err_pp_line_invalid_filename);
DiscardUntilEndOfDirective();
return;
} else if (StrTok.hasUDSuffix()) {
Diag(StrTok, diag::err_invalid_string_udl);
DiscardUntilEndOfDirective();
return;
} else {
// Parse and validate the string, converting it into a unique ID.
StringLiteralParser Literal(StrTok, *this);
assert(Literal.isAscii() && "Didn't allow wide strings in");
if (Literal.hadError) {
DiscardUntilEndOfDirective();
return;
}
if (Literal.Pascal) {
Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
DiscardUntilEndOfDirective();
return;
}
FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString());
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
// Verify that there is nothing after the string, other than EOD. Because
#line is allowed to have macros that expand to nothing after them. llvm-svn: 69401
2009-04-18 07:30:53 +08:00
// of C99 6.10.4p5, macros that expand to empty tokens are ok.
CheckEndOfDirective("line", true);
parse and enforce required constraints on #line directives. Right now we just discard them. llvm-svn: 62999
2009-01-26 13:29:08 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Give files from #line the characteristics of the current file This allows #line directives to appear in system headers that have code that clang would normally warn on. This is compatible with GCC, which is easy to test by running `gcc -E`. Fixes PR30752 llvm-svn: 303582
2017-05-23 05:42:58 +08:00
// Take the file kind of the file containing the #line directive. #line
// directives are often used for generated sources from the same codebase, so
// the new file should generally be classified the same way as the current
// file. This is visible in GCC's pre-processed output, which rewrites #line
// to GNU line markers.
SrcMgr::CharacteristicKind FileKind =
SourceMgr.getFileCharacteristic(DigitTok.getLocation());
SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, false,
false, FileKind);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
push line markers through -E mode. llvm-svn: 67854
2009-03-28 01:13:49 +08:00
if (Callbacks)
Improve line marker directive locations, patch by Jordy Rose llvm-svn: 101226
2010-04-14 12:28:50 +08:00
Callbacks->FileChanged(CurPPLexer->getSourceLocation(),
Give files from #line the characteristics of the current file This allows #line directives to appear in system headers that have code that clang would normally warn on. This is compatible with GCC, which is easy to test by running `gcc -E`. Fixes PR30752 llvm-svn: 303582
2017-05-23 05:42:58 +08:00
PPCallbacks::RenameFile, FileKind);
parse and enforce required constraints on #line directives. Right now we just discard them. llvm-svn: 62999
2009-01-26 13:29:08 +08:00
}
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
/// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line
/// marker directive.
static bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit,
Give files from #line the characteristics of the current file This allows #line directives to appear in system headers that have code that clang would normally warn on. This is compatible with GCC, which is easy to test by running `gcc -E`. Fixes PR30752 llvm-svn: 303582
2017-05-23 05:42:58 +08:00
SrcMgr::CharacteristicKind &FileKind,
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
Preprocessor &PP) {
unsigned FlagVal;
Token FlagTok;
PP.Lex(FlagTok);
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
if (FlagTok.is(tok::eod)) return false;
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))
return true;
if (FlagVal == 1) {
IsFileEntry = true;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
PP.Lex(FlagTok);
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
if (FlagTok.is(tok::eod)) return false;
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP))
return true;
} else if (FlagVal == 2) {
IsFileExit = true;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement handling of file entry/exit notifications from GNU line markers, including maintenance of the virtual include stack. For something like this: # 42 "bar.c" 1 # 142 "bar2.c" 1 #warning zappa # 92 "bar.c" 2 #warning gonzo # 102 "foo.c" 2 #warning bonkta we now produce these three warnings: #1: In file included from foo.c:3: In file included from bar.c:42: bar2.c:143:2: warning: #warning zappa #warning zappa ^ #2: In file included from foo.c:3: bar.c:92:2: warning: #warning gonzo #warning gonzo ^ #3: foo.c:102:2: warning: #warning bonkta #warning bonkta ^ llvm-svn: 63722
2009-02-04 14:25:26 +08:00
SourceManager &SM = PP.getSourceManager();
// If we are leaving the current presumed file, check to make sure the
// presumed include stack isn't empty!
FileID CurFileID =
Rename getDecomposedInstantiationLoc to getDecomposedExpansionLoc. llvm-svn: 135962
2011-07-26 04:52:32 +08:00
SM.getDecomposedExpansionLoc(FlagTok.getLocation()).first;
Implement handling of file entry/exit notifications from GNU line markers, including maintenance of the virtual include stack. For something like this: # 42 "bar.c" 1 # 142 "bar2.c" 1 #warning zappa # 92 "bar.c" 2 #warning gonzo # 102 "foo.c" 2 #warning bonkta we now produce these three warnings: #1: In file included from foo.c:3: In file included from bar.c:42: bar2.c:143:2: warning: #warning zappa #warning zappa ^ #2: In file included from foo.c:3: bar.c:92:2: warning: #warning gonzo #warning gonzo ^ #3: foo.c:102:2: warning: #warning bonkta #warning bonkta ^ llvm-svn: 63722
2009-02-04 14:25:26 +08:00
PresumedLoc PLoc = SM.getPresumedLoc(FlagTok.getLocation());
Make sure to always check the result of SourceManager::getPresumedLoc(), so that we don't try to make use of an invalid presumed location. Doing so can cause crashes. llvm-svn: 118885
2010-11-12 15:15:47 +08:00
if (PLoc.isInvalid())
return true;
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
Implement handling of file entry/exit notifications from GNU line markers, including maintenance of the virtual include stack. For something like this: # 42 "bar.c" 1 # 142 "bar2.c" 1 #warning zappa # 92 "bar.c" 2 #warning gonzo # 102 "foo.c" 2 #warning bonkta we now produce these three warnings: #1: In file included from foo.c:3: In file included from bar.c:42: bar2.c:143:2: warning: #warning zappa #warning zappa ^ #2: In file included from foo.c:3: bar.c:92:2: warning: #warning gonzo #warning gonzo ^ #3: foo.c:102:2: warning: #warning bonkta #warning bonkta ^ llvm-svn: 63722
2009-02-04 14:25:26 +08:00
// If there is no include loc (main file) or if the include loc is in a
// different physical file, then we aren't in a "1" line marker flag region.
SourceLocation IncLoc = PLoc.getIncludeLoc();
if (IncLoc.isInvalid() ||
Rename getDecomposedInstantiationLoc to getDecomposedExpansionLoc. llvm-svn: 135962
2011-07-26 04:52:32 +08:00
SM.getDecomposedExpansionLoc(IncLoc).first != CurFileID) {
Implement handling of file entry/exit notifications from GNU line markers, including maintenance of the virtual include stack. For something like this: # 42 "bar.c" 1 # 142 "bar2.c" 1 #warning zappa # 92 "bar.c" 2 #warning gonzo # 102 "foo.c" 2 #warning bonkta we now produce these three warnings: #1: In file included from foo.c:3: In file included from bar.c:42: bar2.c:143:2: warning: #warning zappa #warning zappa ^ #2: In file included from foo.c:3: bar.c:92:2: warning: #warning gonzo #warning gonzo ^ #3: foo.c:102:2: warning: #warning bonkta #warning bonkta ^ llvm-svn: 63722
2009-02-04 14:25:26 +08:00
PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_pop);
PP.DiscardUntilEndOfDirective();
return true;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
PP.Lex(FlagTok);
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
if (FlagTok.is(tok::eod)) return false;
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP))
return true;
}
// We must have 3 if there are still flags.
if (FlagVal != 3) {
PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);
start plumbing together the line table information. So far we just unique the Filenames in #line directives, assigning them UIDs. llvm-svn: 63010
2009-01-26 15:57:50 +08:00
PP.DiscardUntilEndOfDirective();
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
return true;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Give files from #line the characteristics of the current file This allows #line directives to appear in system headers that have code that clang would normally warn on. This is compatible with GCC, which is easy to test by running `gcc -E`. Fixes PR30752 llvm-svn: 303582
2017-05-23 05:42:58 +08:00
FileKind = SrcMgr::C_System;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
PP.Lex(FlagTok);
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
if (FlagTok.is(tok::eod)) return false;
propagate linemarker flags down into the the line table, currently ignoring include stack push/pop info though. llvm-svn: 63719
2009-02-04 13:21:58 +08:00
if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
return true;
// We must have 4 if there is yet another flag.
if (FlagVal != 4) {
PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);
start plumbing together the line table information. So far we just unique the Filenames in #line directives, assigning them UIDs. llvm-svn: 63010
2009-01-26 15:57:50 +08:00
PP.DiscardUntilEndOfDirective();
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
return true;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Give files from #line the characteristics of the current file This allows #line directives to appear in system headers that have code that clang would normally warn on. This is compatible with GCC, which is easy to test by running `gcc -E`. Fixes PR30752 llvm-svn: 303582
2017-05-23 05:42:58 +08:00
FileKind = SrcMgr::C_ExternCSystem;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
PP.Lex(FlagTok);
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
if (FlagTok.is(tok::eod)) return false;
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
// There are no more valid flags here.
PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);
start plumbing together the line table information. So far we just unique the Filenames in #line directives, assigning them UIDs. llvm-svn: 63010
2009-01-26 15:57:50 +08:00
PP.DiscardUntilEndOfDirective();
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
return true;
}
/// HandleDigitDirective - Handle a GNU line marker directive, whose syntax is
/// one of the following forms:
///
/// # 42
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
/// # 42 "file" ('1' | '2')?
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
/// # 42 "file" ('1' | '2')? '3' '4'?
///
void Preprocessor::HandleDigitDirective(Token &DigitTok) {
// Validate the number and convert it to an unsigned. GNU does not have a
// line # limit other than it fit in 32-bits.
unsigned LineNo;
if (GetLineValue(DigitTok, LineNo, diag::err_pp_linemarker_requires_integer,
Improve the diagnostics of the number-reading preprocessor directives. The GNU line marker directive was sharing code with the #line directive, but some of the warnings/errors were reporting as #line directive diagnostics in both cases. Previously: #line 11foo1 ==> "#line directive requires a simple digit sequence" # 11foo1 ==> "#line directive requires a simple digit sequence" Now, we get: #line 11foo1 ==> "#line directive requires a simple digit sequence" # 11foo1 ==> "GNU line marker directive requires a simple digit sequence" llvm-svn: 179139
2013-04-10 09:04:18 +08:00
*this, true))
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
return;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
Token StrTok;
Lex(StrTok);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
bool IsFileEntry = false, IsFileExit = false;
start plumbing together the line table information. So far we just unique the Filenames in #line directives, assigning them UIDs. llvm-svn: 63010
2009-01-26 15:57:50 +08:00
int FilenameID = -1;
Give files from #line the characteristics of the current file This allows #line directives to appear in system headers that have code that clang would normally warn on. This is compatible with GCC, which is easy to test by running `gcc -E`. Fixes PR30752 llvm-svn: 303582
2017-05-23 05:42:58 +08:00
SrcMgr::CharacteristicKind FileKind = SrcMgr::C_User;
start plumbing together the line table information. So far we just unique the Filenames in #line directives, assigning them UIDs. llvm-svn: 63010
2009-01-26 15:57:50 +08:00
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
// If the StrTok is "eod", then it wasn't present. Otherwise, it must be a
// string followed by eod.
Give files from #line the characteristics of the current file This allows #line directives to appear in system headers that have code that clang would normally warn on. This is compatible with GCC, which is easy to test by running `gcc -E`. Fixes PR30752 llvm-svn: 303582
2017-05-23 05:42:58 +08:00
if (StrTok.is(tok::eod)) {
// Treat this like "#line NN", which doesn't change file characteristics.
Remove random windows line endings that snuck into the middle of this code. llvm-svn: 351633
2019-01-19 14:36:00 +08:00
FileKind = SourceMgr.getFileCharacteristic(DigitTok.getLocation());
} else if (StrTok.isNot(tok::string_literal)) {
Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
DiscardUntilEndOfDirective();
return;
} else if (StrTok.hasUDSuffix()) {
Diag(StrTok, diag::err_invalid_string_udl);
DiscardUntilEndOfDirective();
return;
} else {
// Parse and validate the string, converting it into a unique ID.
StringLiteralParser Literal(StrTok, *this);
assert(Literal.isAscii() && "Didn't allow wide strings in");
if (Literal.hadError) {
DiscardUntilEndOfDirective();
return;
}
if (Literal.Pascal) {
Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
DiscardUntilEndOfDirective();
return;
}
FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString());
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
// If a filename was present, read any flags that are present.
Give files from #line the characteristics of the current file This allows #line directives to appear in system headers that have code that clang would normally warn on. This is compatible with GCC, which is easy to test by running `gcc -E`. Fixes PR30752 llvm-svn: 303582
2017-05-23 05:42:58 +08:00
if (ReadLineMarkerFlags(IsFileEntry, IsFileExit, FileKind, *this))
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
return;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
propagate linemarker flags down into the the line table, currently ignoring include stack push/pop info though. llvm-svn: 63719
2009-02-04 13:21:58 +08:00
// Create a line note with this information.
Give files from #line the characteristics of the current file This allows #line directives to appear in system headers that have code that clang would normally warn on. This is compatible with GCC, which is easy to test by running `gcc -E`. Fixes PR30752 llvm-svn: 303582
2017-05-23 05:42:58 +08:00
SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, IsFileEntry,
IsFileExit, FileKind);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
push line markers through -E mode. llvm-svn: 67854
2009-03-28 01:13:49 +08:00
// If the preprocessor has callbacks installed, notify them of the #line
// change. This is used so that the line marker comes out in -E mode for
// example.
if (Callbacks) {
PPCallbacks::FileChangeReason Reason = PPCallbacks::RenameFile;
if (IsFileEntry)
Reason = PPCallbacks::EnterFile;
else if (IsFileExit)
Reason = PPCallbacks::ExitFile;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Improve line marker directive locations, patch by Jordy Rose llvm-svn: 101226
2010-04-14 12:28:50 +08:00
Callbacks->FileChanged(CurPPLexer->getSourceLocation(), Reason, FileKind);
push line markers through -E mode. llvm-svn: 67854
2009-03-28 01:13:49 +08:00
}
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
}
a few minor cleanups llvm-svn: 63000
2009-01-26 13:30:54 +08:00
/// HandleUserDiagnosticDirective - Handle a #warning or #error directive.
///
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
void Preprocessor::HandleUserDiagnosticDirective(Token &Tok,
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
bool isWarning) {
// Read the rest of the line raw. We do this because we don't want macros
// to be expanded and we don't require that the tokens be valid preprocessing
// tokens. For example, this is allowed: "#warning ` 'foo". GCC does
Fix typos in clang Found via codespell -q 3 -I ../clang-whitelist.txt Where whitelist consists of: archtype cas classs checkk compres definit frome iff inteval ith lod methode nd optin ot pres statics te thru Patch by luzpaz! (This is a subset of D44188 that applies cleanly with a few files that have dubious fixes reverted.) Differential revision: https://reviews.llvm.org/D44188 llvm-svn: 329399
2018-04-06 23:14:32 +08:00
// collapse multiple consecutive white space between tokens, but this isn't
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// specified by the standard.
Lexer::ReadToEndOfLine: Only build the string if it's actually used and do so in a less malloc-intensive way. llvm-svn: 157064
2012-05-19 03:32:16 +08:00
SmallString<128> Message;
CurLexer->ReadToEndOfLine(&Message);
Per discussion on cfe-dev, remove '#error' and '#warning' from diagnostic text. llvm-svn: 149566
2012-02-02 08:16:13 +08:00
// Find the first non-whitespace character, so that we can make the
// diagnostic more succinct.
Revert "Don't convert a char to a const char *" This reverts commit r261780. It turns out the original code was just fine. An overload for ltrim which takes char was added but the Doxygen docs haven't seemed to pick it up. llvm-svn: 261784
2016-02-25 06:07:26 +08:00
StringRef Msg = StringRef(Message).ltrim(' ');
Lexer::ReadToEndOfLine: Only build the string if it's actually used and do so in a less malloc-intensive way. llvm-svn: 157064
2012-05-19 03:32:16 +08:00
parse and enforce required constraints on #line directives. Right now we just discard them. llvm-svn: 62999
2009-01-26 13:29:08 +08:00
if (isWarning)
Per discussion on cfe-dev, remove '#error' and '#warning' from diagnostic text. llvm-svn: 149566
2012-02-02 08:16:13 +08:00
Diag(Tok, diag::pp_hash_warning) << Msg;
parse and enforce required constraints on #line directives. Right now we just discard them. llvm-svn: 62999
2009-01-26 13:29:08 +08:00
else
Per discussion on cfe-dev, remove '#error' and '#warning' from diagnostic text. llvm-svn: 149566
2012-02-02 08:16:13 +08:00
Diag(Tok, diag::err_pp_hash_error) << Msg;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
/// HandleIdentSCCSDirective - Handle a #ident/#sccs directive.
///
void Preprocessor::HandleIdentSCCSDirective(Token &Tok) {
// Yes, this directive is an extension.
Diag(Tok, diag::ext_pp_ident_directive);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Read the string argument.
Token StrTok;
Lex(StrTok);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// If the token kind isn't a string, it's a malformed directive.
if (StrTok.isNot(tok::string_literal) &&
Convert the lexer and start converting the PP over to using canonical Diag methods. llvm-svn: 59511
2008-11-18 15:59:24 +08:00
StrTok.isNot(tok::wide_string_literal)) {
Diag(StrTok, diag::err_pp_malformed_ident);
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
if (StrTok.isNot(tok::eod))
a few minor cleanups llvm-svn: 63000
2009-01-26 13:30:54 +08:00
DiscardUntilEndOfDirective();
Convert the lexer and start converting the PP over to using canonical Diag methods. llvm-svn: 59511
2008-11-18 15:59:24 +08:00
return;
}
Remove random windows line endings that snuck into the middle of this code. llvm-svn: 351633
2019-01-19 14:36:00 +08:00
if (StrTok.hasUDSuffix()) {
Diag(StrTok, diag::err_invalid_string_udl);
DiscardUntilEndOfDirective();
return;
}
// Verify that there is nothing after the string, other than EOD.
Fix the #import / #include_next "extra tokens at end of #foo directive" Warning to properly report that it is an import/include_next instead of claiming it is a #include. llvm-svn: 69023
2009-04-14 13:07:49 +08:00
CheckEndOfDirective("ident");
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Audit all Preprocessor::getSpelling() callers, improving failure recovery for those that need it. llvm-svn: 98689
2010-03-17 06:30:13 +08:00
if (Callbacks) {
bool Invalid = false;
std::string Str = getSpelling(StrTok, &Invalid);
if (!Invalid)
Callbacks->Ident(Tok.getLocation(), Str);
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Handle a #public directive.
Under -fmodules, accept #public <macroname> and #private <macroname> to make a macro public (the default for headers) or private, respectively. llvm-svn: 147455
2012-01-04 02:24:14 +08:00
void Preprocessor::HandleMacroPublicDirective(Token &Tok) {
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
Token MacroNameTok;
Use enumerators instead of hardcoded integers when processing macro names. llvm-svn: 220572
2014-10-25 01:31:32 +08:00
ReadMacroName(MacroNameTok, MU_Undef);
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
// Error reading macro name? If so, diagnostic already issued.
if (MacroNameTok.is(tok::eod))
return;
Re-uglify #public and #private to #__public_macro and #__private_macro. llvm-svn: 147469
2012-01-04 03:48:16 +08:00
// Check to see if this is the last token on the #__public_macro line.
CheckEndOfDirective("__public_macro");
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
// Okay, we finally have a valid identifier to undef.
[modules] Stop trying to fake up a linear MacroDirective history. Modules builds fundamentally have a non-linear macro history. In the interest of better source fidelity, represent the macro definition information faithfully: we have a linear macro directive history within each module, and at any point we have a unique "latest" local macro directive and a collection of visible imported directives. This also removes the attendent complexity of attempting to create a correct MacroDirective history (which we got wrong in the general case). No functionality change intended. llvm-svn: 236176
2015-04-30 07:20:19 +08:00
MacroDirective *MD = getLocalMacroDirective(II);
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
// If the macro is not defined, this is an error.
[C++11] Use 'nullptr'. Lex edition. llvm-svn: 209083
2014-05-18 07:10:59 +08:00
if (!MD) {
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
return;
}
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
// Note that this macro has now been exported.
[Preprocessor/Modules] Separate the macro directives kinds into their own MacroDirective's subclasses. For each macro directive (define, undefine, visibility) have a separate object that gets chained to the macro directive history. This has several benefits: -No need to mutate a MacroDirective when there is a undefine/visibility directive. Stuff like PPMutationListener become unnecessary. -No need to keep extra source locations for the undef/visibility locations for the define directive object (which is the majority of the directives) -Much easier to hide/unhide a section in the macro directive history. -Easier to track the effects of the directives across different submodules. llvm-svn: 178037
2013-03-27 01:17:01 +08:00
appendMacroDirective(II, AllocateVisibilityMacroDirective(
MacroNameTok.getLocation(), /*IsPublic=*/true));
For modules, all macros that aren't include guards are implicitly public. Add a __private_macro__ directive to hide a macro, similar to the __module_private__ declaration specifier. llvm-svn: 142188
2011-10-17 23:32:29 +08:00
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Handle a #private directive.
PP: Remove unused parameters from methods NFC Differential Revision: http://reviews.llvm.org/D25938 llvm-svn: 285180
2016-10-26 16:52:41 +08:00
void Preprocessor::HandleMacroPrivateDirective() {
For modules, all macros that aren't include guards are implicitly public. Add a __private_macro__ directive to hide a macro, similar to the __module_private__ declaration specifier. llvm-svn: 142188
2011-10-17 23:32:29 +08:00
Token MacroNameTok;
Use enumerators instead of hardcoded integers when processing macro names. llvm-svn: 220572
2014-10-25 01:31:32 +08:00
ReadMacroName(MacroNameTok, MU_Undef);
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
For modules, all macros that aren't include guards are implicitly public. Add a __private_macro__ directive to hide a macro, similar to the __module_private__ declaration specifier. llvm-svn: 142188
2011-10-17 23:32:29 +08:00
// Error reading macro name? If so, diagnostic already issued.
if (MacroNameTok.is(tok::eod))
return;
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
Re-uglify #public and #private to #__public_macro and #__private_macro. llvm-svn: 147469
2012-01-04 03:48:16 +08:00
// Check to see if this is the last token on the #__private_macro line.
CheckEndOfDirective("__private_macro");
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
For modules, all macros that aren't include guards are implicitly public. Add a __private_macro__ directive to hide a macro, similar to the __module_private__ declaration specifier. llvm-svn: 142188
2011-10-17 23:32:29 +08:00
// Okay, we finally have a valid identifier to undef.
[modules] Stop trying to fake up a linear MacroDirective history. Modules builds fundamentally have a non-linear macro history. In the interest of better source fidelity, represent the macro definition information faithfully: we have a linear macro directive history within each module, and at any point we have a unique "latest" local macro directive and a collection of visible imported directives. This also removes the attendent complexity of attempting to create a correct MacroDirective history (which we got wrong in the general case). No functionality change intended. llvm-svn: 236176
2015-04-30 07:20:19 +08:00
MacroDirective *MD = getLocalMacroDirective(II);
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
For modules, all macros that aren't include guards are implicitly public. Add a __private_macro__ directive to hide a macro, similar to the __module_private__ declaration specifier. llvm-svn: 142188
2011-10-17 23:32:29 +08:00
// If the macro is not defined, this is an error.
[C++11] Use 'nullptr'. Lex edition. llvm-svn: 209083
2014-05-18 07:10:59 +08:00
if (!MD) {
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;
For modules, all macros that aren't include guards are implicitly public. Add a __private_macro__ directive to hide a macro, similar to the __module_private__ declaration specifier. llvm-svn: 142188
2011-10-17 23:32:29 +08:00
return;
}
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
For modules, all macros that aren't include guards are implicitly public. Add a __private_macro__ directive to hide a macro, similar to the __module_private__ declaration specifier. llvm-svn: 142188
2011-10-17 23:32:29 +08:00
// Note that this macro has now been marked private.
[Preprocessor/Modules] Separate the macro directives kinds into their own MacroDirective's subclasses. For each macro directive (define, undefine, visibility) have a separate object that gets chained to the macro directive history. This has several benefits: -No need to mutate a MacroDirective when there is a undefine/visibility directive. Stuff like PPMutationListener become unnecessary. -No need to keep extra source locations for the undef/visibility locations for the define directive object (which is the majority of the directives) -Much easier to hide/unhide a section in the macro directive history. -Easier to track the effects of the directives across different submodules. llvm-svn: 178037
2013-03-27 01:17:01 +08:00
appendMacroDirective(II, AllocateVisibilityMacroDirective(
MacroNameTok.getLocation(), /*IsPublic=*/false));
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
//===----------------------------------------------------------------------===//
// Preprocessor Include Directive Handling.
//===----------------------------------------------------------------------===//
/// GetIncludeFilenameSpelling - Turn the specified lexer token into a fully
Documentation cleanup: * Add \brief summaries; * Escape # characters in Doxygen comments; * Add \code...\endcode markup for code examples; * Add \verbatim...\endverbatim markup for grammar productions. llvm-svn: 158976
2012-06-22 13:46:07 +08:00
/// checked and spelled filename, e.g. as an operand of \#include. This returns
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
/// true if the input filename was in <>'s or false if it were in ""'s. The
/// caller is expected to provide a buffer that is large enough to hold the
/// spelling of the filename, but is also expected to handle the case when
/// this method decides to use a different buffer.
bool Preprocessor::GetIncludeFilenameSpelling(SourceLocation Loc,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef &Buffer) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Get the text form of the filename.
stringref'ize a bunch of filename handling logic. Much nicer than passing around two const char*'s. llvm-svn: 93094
2010-01-10 09:35:12 +08:00
assert(!Buffer.empty() && "Can't have tokens with empty spellings!");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Replace tok::angle_string_literal with new tok::header_name. Use the new kind for both angled header-name tokens and for double-quoted header-name tokens. This is in preparation for C++20's context-sensitive header-name token formation rules. llvm-svn: 356530
2019-03-20 06:09:55 +08:00
// FIXME: Consider warning on some of the cases described in C11 6.4.7/3 and
// C++20 [lex.header]/2:
//
// If `"`, `'`, `\`, `/*`, or `//` appears in a header-name, then
// in C: behavior is undefined
// in C++: program is conditionally-supported with implementation-defined
// semantics
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Make sure the filename is <x> or "x".
bool isAngled;
stringref'ize a bunch of filename handling logic. Much nicer than passing around two const char*'s. llvm-svn: 93094
2010-01-10 09:35:12 +08:00
if (Buffer[0] == '<') {
if (Buffer.back() != '>') {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Diag(Loc, diag::err_pp_expects_filename);
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
Buffer = StringRef();
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
return true;
}
isAngled = true;
stringref'ize a bunch of filename handling logic. Much nicer than passing around two const char*'s. llvm-svn: 93094
2010-01-10 09:35:12 +08:00
} else if (Buffer[0] == '"') {
if (Buffer.back() != '"') {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Diag(Loc, diag::err_pp_expects_filename);
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
Buffer = StringRef();
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
return true;
}
isAngled = false;
} else {
Diag(Loc, diag::err_pp_expects_filename);
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
Buffer = StringRef();
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
return true;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Diagnose #include "" as invalid.
stringref'ize a bunch of filename handling logic. Much nicer than passing around two const char*'s. llvm-svn: 93094
2010-01-10 09:35:12 +08:00
if (Buffer.size() <= 2) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Diag(Loc, diag::err_pp_empty_filename);
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
Buffer = StringRef();
stringref'ize a bunch of filename handling logic. Much nicer than passing around two const char*'s. llvm-svn: 93094
2010-01-10 09:35:12 +08:00
return true;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Skip the brackets.
stringref'ize a bunch of filename handling logic. Much nicer than passing around two const char*'s. llvm-svn: 93094
2010-01-10 09:35:12 +08:00
Buffer = Buffer.substr(1, Buffer.size()-2);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
return isAngled;
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Push a token onto the token stream containing an annotation.
Add pragma to perform module import and use it in -E output. Many of our supported configurations support modules but do not have any first-class syntax to perform a module import. This leaves us with a problem: there is no way to represent the expansion of a #include that imports a module in the -E output for such languages. (We don't want to just leave it as a #include because that requires the consumer of the preprocessed source to have the same file system layout and include paths as the creator.) This patch adds a new pragma: #pragma clang module import MODULE.NAME.HERE that imports a module, and changes -E and -frewrite-includes to use it when rewriting a #include that maps to a module import. We don't make any attempt to use a native language syntax import if one exists, to get more consistent output. (If in the future, @import and #include have different semantics in some way, the pragma will track the #include semantics.) llvm-svn: 301725
2017-04-29 08:34:47 +08:00
void Preprocessor::EnterAnnotationToken(SourceRange Range,
tok::TokenKind Kind,
void *AnnotationVal) {
[modules] Rearrange preprocessor module visibility handling, no observable change intended. llvm-svn: 237331
2015-05-14 10:25:44 +08:00
// FIXME: Produce this as the current token directly, rather than
// allocating a new token for it.
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
auto Tok = llvm::make_unique<Token[]>(1);
Generate a marker token when entering or leaving a submodule when building a module. Use the marker to diagnose cases where we try to transition between submodules when not at the top level (most likely because a closing brace was missing at the end of a header file, but is also possible if submodule headers attempt to do something fundamentally non-modular, like our .def files). llvm-svn: 195543
2013-11-23 12:06:09 +08:00
Tok[0].startToken();
Tok[0].setKind(Kind);
Add pragma to perform module import and use it in -E output. Many of our supported configurations support modules but do not have any first-class syntax to perform a module import. This leaves us with a problem: there is no way to represent the expansion of a #include that imports a module in the -E output for such languages. (We don't want to just leave it as a #include because that requires the consumer of the preprocessed source to have the same file system layout and include paths as the creator.) This patch adds a new pragma: #pragma clang module import MODULE.NAME.HERE that imports a module, and changes -E and -frewrite-includes to use it when rewriting a #include that maps to a module import. We don't make any attempt to use a native language syntax import if one exists, to get more consistent output. (If in the future, @import and #include have different semantics in some way, the pragma will track the #include semantics.) llvm-svn: 301725
2017-04-29 08:34:47 +08:00
Tok[0].setLocation(Range.getBegin());
Tok[0].setAnnotationEndLoc(Range.getEnd());
Generate a marker token when entering or leaving a submodule when building a module. Use the marker to diagnose cases where we try to transition between submodules when not at the top level (most likely because a closing brace was missing at the end of a header file, but is also possible if submodule headers attempt to do something fundamentally non-modular, like our .def files). llvm-svn: 195543
2013-11-23 12:06:09 +08:00
Tok[0].setAnnotationValue(AnnotationVal);
Add pragma to perform module import and use it in -E output. Many of our supported configurations support modules but do not have any first-class syntax to perform a module import. This leaves us with a problem: there is no way to represent the expansion of a #include that imports a module in the -E output for such languages. (We don't want to just leave it as a #include because that requires the consumer of the preprocessed source to have the same file system layout and include paths as the creator.) This patch adds a new pragma: #pragma clang module import MODULE.NAME.HERE that imports a module, and changes -E and -frewrite-includes to use it when rewriting a #include that maps to a module import. We don't make any attempt to use a native language syntax import if one exists, to get more consistent output. (If in the future, @import and #include have different semantics in some way, the pragma will track the #include semantics.) llvm-svn: 301725
2017-04-29 08:34:47 +08:00
EnterTokenStream(std::move(Tok), 1, true);
Generate a marker token when entering or leaving a submodule when building a module. Use the marker to diagnose cases where we try to transition between submodules when not at the top level (most likely because a closing brace was missing at the end of a header file, but is also possible if submodule headers attempt to do something fundamentally non-modular, like our .def files). llvm-svn: 195543
2013-11-23 12:06:09 +08:00
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Produce a diagnostic informing the user that a #include or similar
[modules] Refactor and simplify #include handling. Fix a tiny bug where we'd try to load a module file for the module we're in the middle of building. llvm-svn: 237552
2015-05-18 12:45:41 +08:00
/// was implicitly treated as a module import.
static void diagnoseAutoModuleImport(
Preprocessor &PP, SourceLocation HashLoc, Token &IncludeTok,
ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> Path,
SourceLocation PathEnd) {
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
StringRef ImportKeyword;
if (PP.getLangOpts().ObjC)
ImportKeyword = "@import";
else if (PP.getLangOpts().ModulesTS || PP.getLangOpts().CPlusPlusModules)
ImportKeyword = "import";
else
return; // no import syntax available
[modules] Refactor and simplify #include handling. Fix a tiny bug where we'd try to load a module file for the module we're in the middle of building. llvm-svn: 237552
2015-05-18 12:45:41 +08:00
SmallString<128> PathString;
[PP] Replace some uses of unsigned with size_t All values are returned by a method as size_t, and subsequently passed to functions taking a size_t, or used where a size_t is also valid. Better still, two loops (which had an unsigned), can be replaced by a range-based for loop. Differential Revision: http://reviews.llvm.org/D25939 llvm-svn: 285182
2016-10-26 17:58:31 +08:00
for (size_t I = 0, N = Path.size(); I != N; ++I) {
[modules] Refactor and simplify #include handling. Fix a tiny bug where we'd try to load a module file for the module we're in the middle of building. llvm-svn: 237552
2015-05-18 12:45:41 +08:00
if (I)
PathString += '.';
PathString += Path[I].first->getName();
}
int IncludeKind = 0;
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
[modules] Refactor and simplify #include handling. Fix a tiny bug where we'd try to load a module file for the module we're in the middle of building. llvm-svn: 237552
2015-05-18 12:45:41 +08:00
switch (IncludeTok.getIdentifierInfo()->getPPKeywordID()) {
case tok::pp_include:
IncludeKind = 0;
break;
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
[modules] Refactor and simplify #include handling. Fix a tiny bug where we'd try to load a module file for the module we're in the middle of building. llvm-svn: 237552
2015-05-18 12:45:41 +08:00
case tok::pp_import:
IncludeKind = 1;
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
break;
[modules] Refactor and simplify #include handling. Fix a tiny bug where we'd try to load a module file for the module we're in the middle of building. llvm-svn: 237552
2015-05-18 12:45:41 +08:00
case tok::pp_include_next:
IncludeKind = 2;
break;
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
[modules] Refactor and simplify #include handling. Fix a tiny bug where we'd try to load a module file for the module we're in the middle of building. llvm-svn: 237552
2015-05-18 12:45:41 +08:00
case tok::pp___include_macros:
IncludeKind = 3;
break;
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
[modules] Refactor and simplify #include handling. Fix a tiny bug where we'd try to load a module file for the module we're in the middle of building. llvm-svn: 237552
2015-05-18 12:45:41 +08:00
default:
llvm_unreachable("unknown include directive kind");
}
CharSourceRange ReplaceRange(SourceRange(HashLoc, PathEnd),
/*IsTokenRange=*/false);
PP.Diag(HashLoc, diag::warn_auto_module_import)
<< IncludeKind << PathString
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
<< FixItHint::CreateReplacement(
ReplaceRange, (ImportKeyword + " " + PathString + ";").str());
[modules] Refactor and simplify #include handling. Fix a tiny bug where we'd try to load a module file for the module we're in the middle of building. llvm-svn: 237552
2015-05-18 12:45:41 +08:00
}
Use the name of the file on disk to issue a new diagnostic about non-portable #include and #import paths. Differential Revision: http://reviews.llvm.org/D19843 Corresponding LLVM change: http://reviews.llvm.org/D19842 Re-commit of r272562 after addressing clang-x86-win2008-selfhost failure. llvm-svn: 272584
2016-06-14 04:40:21 +08:00
// Given a vector of path components and a string containing the real
// path to the file, build a properly-cased replacement in the vector,
// and return true if the replacement should be suggested.
static bool trySimplifyPath(SmallVectorImpl<StringRef> &Components,
StringRef RealPathName) {
auto RealPathComponentIter = llvm::sys::path::rbegin(RealPathName);
auto RealPathComponentEnd = llvm::sys::path::rend(RealPathName);
int Cnt = 0;
bool SuggestReplacement = false;
// Below is a best-effort to handle ".." in paths. It is admittedly
// not 100% correct in the presence of symlinks.
for (auto &Component : llvm::reverse(Components)) {
if ("." == Component) {
} else if (".." == Component) {
++Cnt;
} else if (Cnt) {
--Cnt;
} else if (RealPathComponentIter != RealPathComponentEnd) {
if (Component != *RealPathComponentIter) {
// If these path components differ by more than just case, then we
// may be looking at symlinked paths. Bail on this diagnostic to avoid
// noisy false positives.
SuggestReplacement = RealPathComponentIter->equals_lower(Component);
if (!SuggestReplacement)
break;
Component = *RealPathComponentIter;
}
++RealPathComponentIter;
}
}
return SuggestReplacement;
}
Factor out and unify emission of "module is unavailable" diagnostics. Inspired by post-commit review of r304190. llvm-svn: 304728
2017-06-06 02:57:56 +08:00
bool Preprocessor::checkModuleIsAvailable(const LangOptions &LangOpts,
const TargetInfo &TargetInfo,
DiagnosticsEngine &Diags, Module *M) {
Module::Requirement Requirement;
Module::UnresolvedHeaderDirective MissingHeader;
Reapply r321781: [Modules] Allow modules specified by -fmodule-map-file to shadow implicitly found ones When modules come from module map files explicitly specified by -fmodule-map-file= arguments, allow those to override/shadow modules with the same name that are found implicitly by header search. If such a module is looked up by name (e.g. @import), we will always find the one from -fmodule-map-file. If we try to use a shadowed module by including one of its headers report an error. This enables developers to force use of a specific copy of their module to be used if there are multiple copies that would otherwise be visible, for example if they develop modules that are installed in the default search paths. Patch originally by Ben Langmuir, http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20151116/143425.html Based on cfe-dev discussion: http://lists.llvm.org/pipermail/cfe-dev/2015-November/046164.html Differential Revision: https://reviews.llvm.org/D31269 rdar://problem/23612102 llvm-svn: 321855
2018-01-05 10:33:18 +08:00
Module *ShadowingModule = nullptr;
if (M->isAvailable(LangOpts, TargetInfo, Requirement, MissingHeader,
ShadowingModule))
Factor out and unify emission of "module is unavailable" diagnostics. Inspired by post-commit review of r304190. llvm-svn: 304728
2017-06-06 02:57:56 +08:00
return false;
if (MissingHeader.FileNameLoc.isValid()) {
Diags.Report(MissingHeader.FileNameLoc, diag::err_module_header_missing)
<< MissingHeader.IsUmbrella << MissingHeader.FileName;
Reapply r321781: [Modules] Allow modules specified by -fmodule-map-file to shadow implicitly found ones When modules come from module map files explicitly specified by -fmodule-map-file= arguments, allow those to override/shadow modules with the same name that are found implicitly by header search. If such a module is looked up by name (e.g. @import), we will always find the one from -fmodule-map-file. If we try to use a shadowed module by including one of its headers report an error. This enables developers to force use of a specific copy of their module to be used if there are multiple copies that would otherwise be visible, for example if they develop modules that are installed in the default search paths. Patch originally by Ben Langmuir, http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20151116/143425.html Based on cfe-dev discussion: http://lists.llvm.org/pipermail/cfe-dev/2015-November/046164.html Differential Revision: https://reviews.llvm.org/D31269 rdar://problem/23612102 llvm-svn: 321855
2018-01-05 10:33:18 +08:00
} else if (ShadowingModule) {
Diags.Report(M->DefinitionLoc, diag::err_module_shadowed) << M->Name;
Diags.Report(ShadowingModule->DefinitionLoc,
diag::note_previous_definition);
Factor out and unify emission of "module is unavailable" diagnostics. Inspired by post-commit review of r304190. llvm-svn: 304728
2017-06-06 02:57:56 +08:00
} else {
// FIXME: Track the location at which the requirement was specified, and
// use it here.
Diags.Report(M->DefinitionLoc, diag::err_module_unavailable)
<< M->getFullModuleName() << Requirement.second << Requirement.first;
}
return true;
}
Documentation cleanup: * Add \brief summaries; * Escape # characters in Doxygen comments; * Add \code...\endcode markup for code examples; * Add \verbatim...\endverbatim markup for grammar productions. llvm-svn: 158976
2012-06-22 13:46:07 +08:00
/// HandleIncludeDirective - The "\#include" tokens have just been read, read
/// the file to be included from the lexer, then include it! This is a common
/// routine with functionality shared between \#include, \#include_next and
/// \#import. LookupFrom is set when this is a \#include_next directive, it
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
/// specifies the file to start searching from.
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc,
Extend the preprocessing record and libclang with support for inclusion directives, keeping track of every #include, #import, etc. in the translation unit. We keep track of the source location and kind of the inclusion, how the file name was spelled, and the underlying file to which the inclusion resolved. llvm-svn: 116952
2010-10-21 06:00:55 +08:00
Token &IncludeTok,
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
const DirectoryLookup *LookupFrom,
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
const FileEntry *LookupFromFile) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Token FilenameTok;
Factor out repeated code parsing and concatenating header-names from tokens. We now actually form an angled_string_literal token for a header name by concatenation rather than just working out what its contents would be. This substantially simplifies downstream processing and is necessary for C++20 header unit imports. llvm-svn: 356433
2019-03-19 09:51:19 +08:00
if (LexHeaderName(FilenameTok))
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
return;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Replace tok::angle_string_literal with new tok::header_name. Use the new kind for both angled header-name tokens and for double-quoted header-name tokens. This is in preparation for C++20's context-sensitive header-name token formation rules. llvm-svn: 356530
2019-03-20 06:09:55 +08:00
if (FilenameTok.isNot(tok::header_name)) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename);
Factor out repeated code parsing and concatenating header-names from tokens. We now actually form an angled_string_literal token for a header name by concatenation rather than just working out what its contents would be. This substantially simplifies downstream processing and is necessary for C++20 header unit imports. llvm-svn: 356433
2019-03-19 09:51:19 +08:00
if (FilenameTok.isNot(tok::eod))
DiscardUntilEndOfDirective();
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
return;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
// Verify that there is nothing after the filename, other than EOD. Note
// that we allow macros that expand to nothing after the filename, because
// this falls into the category of "#include pp-tokens new-line" specified
// in C99 6.10.2p4.
SourceLocation EndLoc =
CheckEndOfDirective(IncludeTok.getIdentifierInfo()->getNameStart(), true);
auto Action = HandleHeaderIncludeOrImport(HashLoc, IncludeTok, FilenameTok,
EndLoc, LookupFrom, LookupFromFile);
switch (Action.Kind) {
case ImportAction::None:
break;
case ImportAction::ModuleBegin:
EnterAnnotationToken(SourceRange(HashLoc, EndLoc),
tok::annot_module_begin, Action.ModuleForHeader);
break;
case ImportAction::ModuleImport:
EnterAnnotationToken(SourceRange(HashLoc, EndLoc),
tok::annot_module_include, Action.ModuleForHeader);
break;
}
}
/// Handle either a #include-like directive or an import declaration that names
/// a header file.
///
/// \param HashLoc The location of the '#' token for an include, or
/// SourceLocation() for an import declaration.
/// \param IncludeTok The include / include_next / import token.
/// \param FilenameTok The header-name token.
/// \param EndLoc The location at which any imported macros become visible.
/// \param LookupFrom For #include_next, the starting directory for the
/// directory lookup.
/// \param LookupFromFile For #include_next, the starting file for the directory
/// lookup.
Preprocessor::ImportAction Preprocessor::HandleHeaderIncludeOrImport(
SourceLocation HashLoc, Token &IncludeTok, Token &FilenameTok,
SourceLocation EndLoc, const DirectoryLookup *LookupFrom,
const FileEntry *LookupFromFile) {
Factor out repeated code parsing and concatenating header-names from tokens. We now actually form an angled_string_literal token for a header name by concatenation rather than just working out what its contents would be. This substantially simplifies downstream processing and is necessary for C++20 header unit imports. llvm-svn: 356433
2019-03-19 09:51:19 +08:00
SmallString<128> FilenameBuffer;
StringRef Filename = getSpelling(FilenameTok, FilenameBuffer);
SourceLocation CharEnd = FilenameTok.getEndLoc();
For PPCallbacks::InclusionDirective() add a parameter for the module, whenever an inclusion directive was automatically turned into a module import, and PPCallbacks::moduleImport() for an explicit module import. llvm-svn: 164874
2012-09-29 09:06:10 +08:00
CharSourceRange FilenameRange
= CharSourceRange::getCharRange(FilenameTok.getLocation(), CharEnd);
Adding support for #pragma include_alias in MS compatibility mode. This implements PR 10705. llvm-svn: 151949
2012-03-03 06:51:54 +08:00
StringRef OriginalFilename = Filename;
Use SmallString instead of SmallVector llvm-svn: 98436
2010-03-13 18:17:05 +08:00
bool isAngled =
stringref'ize a bunch of filename handling logic. Much nicer than passing around two const char*'s. llvm-svn: 93094
2010-01-10 09:35:12 +08:00
GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename);
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// If GetIncludeFilenameSpelling set the start ptr to null, there was an
// error.
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
if (Filename.empty())
return {ImportAction::None};
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
bool IsImportDecl = HashLoc.isInvalid();
SourceLocation StartLoc = IsImportDecl ? IncludeTok.getLocation() : HashLoc;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Add explicit attributes to mark functions as having had their CoreFoundation object-transfer properties audited, and add a #pragma to cause them to be automatically applied to functions in a particular span of code. This has to be implemented largely in the preprocessor because of the requirement that the region be entirely contained in a single file; that's hard to impose from the parser without registering for a ton of callbacks. llvm-svn: 140846
2011-09-30 13:12:12 +08:00
// Complain about attempts to #include files in an audit pragma.
if (PragmaARCCFCodeAuditedLoc.isValid()) {
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
Diag(StartLoc, diag::err_pp_include_in_arc_cf_code_audited) << IsImportDecl;
Add explicit attributes to mark functions as having had their CoreFoundation object-transfer properties audited, and add a #pragma to cause them to be automatically applied to functions in a particular span of code. This has to be implemented largely in the preprocessor because of the requirement that the region be entirely contained in a single file; that's hard to impose from the parser without registering for a ton of callbacks. llvm-svn: 140846
2011-09-30 13:12:12 +08:00
Diag(PragmaARCCFCodeAuditedLoc, diag::note_pragma_entered_here);
// Immediately leave the pragma.
PragmaARCCFCodeAuditedLoc = SourceLocation();
}
Introduced pragmas for audited nullability regions. Introduce the clang pragmas "assume_nonnull begin" and "assume_nonnull end" in which we make default assumptions about the nullability of many unannotated pointers: - Single-level pointers are inferred to __nonnull - NSError** in a (function or method) parameter list is inferred to NSError * __nullable * __nullable. - CFErrorRef * in a (function or method) parameter list is inferred to CFErrorRef __nullable * __nullable. - Other multi-level pointers are never inferred to anything. Implements rdar://problem/19191042. llvm-svn: 240156
2015-06-20 02:25:57 +08:00
// Complain about attempts to #include files in an assume-nonnull pragma.
if (PragmaAssumeNonNullLoc.isValid()) {
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
Diag(StartLoc, diag::err_pp_include_in_assume_nonnull) << IsImportDecl;
Introduced pragmas for audited nullability regions. Introduce the clang pragmas "assume_nonnull begin" and "assume_nonnull end" in which we make default assumptions about the nullability of many unannotated pointers: - Single-level pointers are inferred to __nonnull - NSError** in a (function or method) parameter list is inferred to NSError * __nullable * __nullable. - CFErrorRef * in a (function or method) parameter list is inferred to CFErrorRef __nullable * __nullable. - Other multi-level pointers are never inferred to anything. Implements rdar://problem/19191042. llvm-svn: 240156
2015-06-20 02:25:57 +08:00
Diag(PragmaAssumeNonNullLoc, diag::note_pragma_entered_here);
// Immediately leave the pragma.
PragmaAssumeNonNullLoc = SourceLocation();
}
Adding support for #pragma include_alias in MS compatibility mode. This implements PR 10705. llvm-svn: 151949
2012-03-03 06:51:54 +08:00
if (HeaderInfo.HasIncludeAliasMap()) {
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
// Map the filename with the brackets still attached. If the name doesn't
// map to anything, fall back on the filename we've already gotten the
Adding support for #pragma include_alias in MS compatibility mode. This implements PR 10705. llvm-svn: 151949
2012-03-03 06:51:54 +08:00
// spelling for.
StringRef NewName = HeaderInfo.MapHeaderToIncludeAlias(OriginalFilename);
if (!NewName.empty())
Filename = NewName;
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Search include directories.
Preprocessor: Suppress -Wnonportable-include-path for header maps If a file search involves a header map, suppress -Wnonportable-include-path. It's firing lots of false positives for framework authors internally, and it's not trivial to fix. Consider a framework called "Foo" with a main (installed) framework header "Foo/Foo.h". It's atypical for "Foo.h" to actually live inside a directory called "Foo" in the source repository. Instead, the build system generates a header map while building the framework. If Foo.h lives at the top-level of the source repository (common), and the git repo is called ssh://some.url/foo.git, then the header map will have something like: Foo/Foo.h -> /Users/myname/code/foo/Foo.h where "/Users/myname/code/foo" is the clone of ssh://some.url/foo.git. After #import <Foo/Foo.h>, the current implementation of -Wnonportable-include-path will falsely assume that Foo.h was found in a nonportable way, because of the name of the git clone (.../foo/Foo.h). However, that directory name was not involved in the header search at all. This commit adds an extra parameter to Preprocessor::LookupFile and HeaderSearch::LookupFile to track if the search used a header map, making it easy to suppress the warning. Longer term, once we find a way to avoid the false positive, we should turn the warning back on. rdar://problem/28863903 llvm-svn: 301592
2017-04-28 05:41:51 +08:00
bool IsMapped = false;
[Preprocessor] Add a note with framework location for "file not found" error. When a framework with the same name is available at multiple framework search paths, we use the first matching location. If a framework at this location doesn't have all the headers, it can be confusing for developers because they see only an error `'Foo/Foo.h' file not found`, can find the complete framework with required header, and don't know the incomplete framework was used instead. Add a note explaining a framework without required header was found. Also mention framework directory path to make it easier to find the incomplete framework. rdar://problem/39246514 Reviewers: arphaman, erik.pilkington, jkorous Reviewed By: jkorous Subscribers: jkorous, dexonsmith, cfe-commits Differential Revision: https://reviews.llvm.org/D56561 llvm-svn: 353231
2019-02-06 06:34:55 +08:00
bool IsFrameworkFound = false;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
const DirectoryLookup *CurDir;
Basic: import SmallString<> into clang namespace (I was going to fix the TODO about DenseMap too, but that would break self-host right now. See PR11922.) llvm-svn: 149799
2012-02-05 10:13:05 +08:00
SmallString<1024> SearchPath;
SmallString<1024> RelativePath;
Add a 'RawPath' parameter to the PPCallbacks interface. This allows clients to observe the exact path through which an #included file was located. This is very useful when trying to record and replay inclusion operations without it beind influenced by the aggressive caching done inside the FileManager to avoid redundant system calls and filesystem operations. The work to compute and return this is only done in the presence of callbacks, so it should have no effect on normal compilation. Patch by Manuel Klimek. llvm-svn: 127742
2011-03-17 02:34:36 +08:00
// We get the raw path only if we have 'Callbacks' to which we later pass
// the path.
This patch adds new private headers to the module map. Private headers may be included from within the module, but not from outside the module. llvm-svn: 184471
2013-06-21 05:14:14 +08:00
ModuleMap::KnownHeader SuggestedModule;
SourceLocation FilenameLoc = FilenameTok.getLocation();
Lex: reduce buffer size, add a test Reduce the stack usage as hopefully include paths are usually not too long. Add a test case for the path normalisation behaviour. llvm-svn: 203632
2014-03-12 10:26:08 +08:00
SmallString<128> NormalizedPath;
lex: improve include handling on Linux for Windows Normalise the path separator character on non-windows platforms. Although this would work on Windows as well (most newer versions of Windows support either '/' or '\' as a path separator character), it could potentially cause problems with full UNC paths. This change enables the use of the Windows SDK on Linux which will not accept '\' as a path separator. llvm-svn: 203614
2014-03-12 06:41:45 +08:00
if (LangOpts.MSVCCompat) {
NormalizedPath = Filename.str();
s/LLVM_ON_WIN32/_WIN32/, clang LLVM_ON_WIN32 is set exactly with MSVC and MinGW (but not Cygwin) in HandleLLVMOptions.cmake, which is where _WIN32 defined too. Just use the default macro instead of a reinvented one. See thread "Replacing LLVM_ON_WIN32 with just _WIN32" on llvm-dev and cfe-dev. No intended behavior change. llvm-svn: 331069
2018-04-28 03:11:14 +08:00
#ifndef _WIN32
Use llvm::sys::path::native instead of llvm::sys::fs::normalize_separators. llvm::sys::path::native has a superset of the functionality and this was the only use of llvm::sys::fs::normalize_separators. llvm-svn: 215242
2014-08-09 05:31:04 +08:00
llvm::sys::path::native(NormalizedPath);
Fix six tests are failing on Windows after r215241-r215243. Clang :: Frontend/iframework.c Clang :: Frontend/system-header-prefix.c Clang :: Index/annotate-comments-objc.m Clang :: Index/annotate-module.m Clang :: Index/index-module.m Clang :: Index/index-pch-with-module.m Clang :: PCH/case-insensitive-include.c Suprisingly the normalize_separators() was no-op when LLVM_ON_WIN32. Its replacement native() does change path separators into \ as expected, breaking these tests. I had fixed the tests by #ifndef LLVM_ON_WIN32 on the native call, to match the previous behaviour. If this logic is not used on Windows host, it might be completely deleted as there should not be windows path seperators on Linux hosts. I can't test on Linux but if someone can run tests on Linux after commenting out the line llvm::sys::path::native(NormalizedPath); and the tests pass, the whole if (LangOpts.MSVCCompat) could be deleted. llvm-svn: 215290
2014-08-10 02:13:01 +08:00
#endif
lex: improve include handling on Linux for Windows Normalise the path separator character on non-windows platforms. Although this would work on Windows as well (most newer versions of Windows support either '/' or '\' as a path separator character), it could potentially cause problems with full UNC paths. This change enables the use of the Windows SDK on Linux which will not accept '\' as a path separator. llvm-svn: 203614
2014-03-12 06:41:45 +08:00
}
Add a 'RawPath' parameter to the PPCallbacks interface. This allows clients to observe the exact path through which an #included file was located. This is very useful when trying to record and replay inclusion operations without it beind influenced by the aggressive caching done inside the FileManager to avoid redundant system calls and filesystem operations. The work to compute and return this is only done in the presence of callbacks, so it should have no effect on normal compilation. Patch by Manuel Klimek. llvm-svn: 127742
2011-03-17 02:34:36 +08:00
const FileEntry *File = LookupFile(
lex: improve include handling on Linux for Windows Normalise the path separator character on non-windows platforms. Although this would work on Windows as well (most newer versions of Windows support either '/' or '\' as a path separator character), it could potentially cause problems with full UNC paths. This change enables the use of the Windows SDK on Linux which will not accept '\' as a path separator. llvm-svn: 203614
2014-03-12 06:41:45 +08:00
FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename,
[modules] Add support for #include_next. #include_next interacts poorly with modules: it depends on where in the list of include paths the current file was found. Files covered by module maps are not found in include search paths when building the module (and are not found in include search paths when @importing the module either), so this isn't really meaningful. Instead, we fake up the result that #include_next *should* have given: find the first path that would have resulted in the given file being picked, and search from there onwards. llvm-svn: 220177
2014-10-20 08:15:49 +08:00
isAngled, LookupFrom, LookupFromFile, CurDir,
Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr,
[Preprocessor] Add a note with framework location for "file not found" error. When a framework with the same name is available at multiple framework search paths, we use the first matching location. If a framework at this location doesn't have all the headers, it can be confusing for developers because they see only an error `'Foo/Foo.h' file not found`, can find the complete framework with required header, and don't know the incomplete framework was used instead. Add a note explaining a framework without required header was found. Also mention framework directory path to make it easier to find the incomplete framework. rdar://problem/39246514 Reviewers: arphaman, erik.pilkington, jkorous Reviewed By: jkorous Subscribers: jkorous, dexonsmith, cfe-commits Differential Revision: https://reviews.llvm.org/D56561 llvm-svn: 353231
2019-02-06 06:34:55 +08:00
&SuggestedModule, &IsMapped, &IsFrameworkFound);
Add an experimental flag -fauto-module-import that automatically turns #include or #import direcctives of framework headers into module imports of the corresponding framework module. llvm-svn: 139860
2011-09-16 06:00:41 +08:00
[modules] Rearrange preprocessor module visibility handling, no observable change intended. llvm-svn: 237331
2015-05-14 10:25:44 +08:00
if (!File) {
if (Callbacks) {
Move the module auto-import logic after the logic that allows a callback client to suggest an alternative search path and after we complain when the included file can't be found. The former can't be tested in isolation, the latter doesn't actually matter (because we won't make a module suggestion if no header is available). However, the flow is better this way. llvm-svn: 145502
2011-12-01 02:12:06 +08:00
// Give the clients a chance to recover.
Basic: import SmallString<> into clang namespace (I was going to fix the TODO about DenseMap too, but that would break self-host right now. See PR11922.) llvm-svn: 149799
2012-02-05 10:13:05 +08:00
SmallString<128> RecoveryPath;
Move the module auto-import logic after the logic that allows a callback client to suggest an alternative search path and after we complain when the included file can't be found. The former can't be tested in isolation, the latter doesn't actually matter (because we won't make a module suggestion if no header is available). However, the flow is better this way. llvm-svn: 145502
2011-12-01 02:12:06 +08:00
if (Callbacks->FileNotFound(Filename, RecoveryPath)) {
if (const DirectoryEntry *DE = FileMgr.getDirectory(RecoveryPath)) {
// Add the recovery path to the list of search paths.
[Lex] Remove DirectoryLookup.UserSpecified, which is unused. llvm-svn: 173409
2013-01-25 09:50:28 +08:00
DirectoryLookup DL(DE, SrcMgr::C_User, false);
Move the module auto-import logic after the logic that allows a callback client to suggest an alternative search path and after we complain when the included file can't be found. The former can't be tested in isolation, the latter doesn't actually matter (because we won't make a module suggestion if no header is available). However, the flow is better this way. llvm-svn: 145502
2011-12-01 02:12:06 +08:00
HeaderInfo.AddSearchPath(DL, isAngled);
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
Move the module auto-import logic after the logic that allows a callback client to suggest an alternative search path and after we complain when the included file can't be found. The former can't be tested in isolation, the latter doesn't actually matter (because we won't make a module suggestion if no header is available). However, the flow is better this way. llvm-svn: 145502
2011-12-01 02:12:06 +08:00
// Try the lookup again, skipping the cache.
[modules] Add support for #include_next. #include_next interacts poorly with modules: it depends on where in the list of include paths the current file was found. Files covered by module maps are not found in include search paths when building the module (and are not found in include search paths when @importing the module either), so this isn't really meaningful. Instead, we fake up the result that #include_next *should* have given: find the first path that would have resulted in the given file being picked, and search from there onwards. llvm-svn: 220177
2014-10-20 08:15:49 +08:00
File = LookupFile(
FilenameLoc,
LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled,
LookupFrom, LookupFromFile, CurDir, nullptr, nullptr,
[Preprocessor] Add a note with framework location for "file not found" error. When a framework with the same name is available at multiple framework search paths, we use the first matching location. If a framework at this location doesn't have all the headers, it can be confusing for developers because they see only an error `'Foo/Foo.h' file not found`, can find the complete framework with required header, and don't know the incomplete framework was used instead. Add a note explaining a framework without required header was found. Also mention framework directory path to make it easier to find the incomplete framework. rdar://problem/39246514 Reviewers: arphaman, erik.pilkington, jkorous Reviewed By: jkorous Subscribers: jkorous, dexonsmith, cfe-commits Differential Revision: https://reviews.llvm.org/D56561 llvm-svn: 353231
2019-02-06 06:34:55 +08:00
&SuggestedModule, &IsMapped, /*IsFrameworkFound=*/nullptr,
/*SkipCache*/ true);
Move the module auto-import logic after the logic that allows a callback client to suggest an alternative search path and after we complain when the included file can't be found. The former can't be tested in isolation, the latter doesn't actually matter (because we won't make a module suggestion if no header is available). However, the flow is better this way. llvm-svn: 145502
2011-12-01 02:12:06 +08:00
}
}
}
[C++11] Use 'nullptr'. Lex edition. llvm-svn: 209083
2014-05-18 07:10:59 +08:00
Adding a fixit for includes that cannot be found with angle brackets, but can be found with quoted strings instead. Implements PR13201. llvm-svn: 160406
2012-07-18 07:19:16 +08:00
if (!SuppressIncludeNotFoundError) {
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
// If the file could not be located and it was included via angle
Adding a fixit for includes that cannot be found with angle brackets, but can be found with quoted strings instead. Implements PR13201. llvm-svn: 160406
2012-07-18 07:19:16 +08:00
// brackets, we can attempt a lookup as though it were a quoted path to
// provide the user with a possible fixit.
if (isAngled) {
Add option to disable module loading. This patch was created by Lawrence Crowl and reviewed in: http://llvm-reviews.chandlerc.com/D963 llvm-svn: 187738
2013-08-06 04:26:17 +08:00
File = LookupFile(
[modules] Add support for #include_next. #include_next interacts poorly with modules: it depends on where in the list of include paths the current file was found. Files covered by module maps are not found in include search paths when building the module (and are not found in include search paths when @importing the module either), so this isn't really meaningful. Instead, we fake up the result that #include_next *should* have given: find the first path that would have resulted in the given file being picked, and search from there onwards. llvm-svn: 220177
2014-10-20 08:15:49 +08:00
FilenameLoc,
LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, false,
LookupFrom, LookupFromFile, CurDir,
Callbacks ? &SearchPath : nullptr,
[Preprocessor] Add a note with framework location for "file not found" error. When a framework with the same name is available at multiple framework search paths, we use the first matching location. If a framework at this location doesn't have all the headers, it can be confusing for developers because they see only an error `'Foo/Foo.h' file not found`, can find the complete framework with required header, and don't know the incomplete framework was used instead. Add a note explaining a framework without required header was found. Also mention framework directory path to make it easier to find the incomplete framework. rdar://problem/39246514 Reviewers: arphaman, erik.pilkington, jkorous Reviewed By: jkorous Subscribers: jkorous, dexonsmith, cfe-commits Differential Revision: https://reviews.llvm.org/D56561 llvm-svn: 353231
2019-02-06 06:34:55 +08:00
Callbacks ? &RelativePath : nullptr, &SuggestedModule, &IsMapped,
/*IsFrameworkFound=*/nullptr);
Adding a fixit for includes that cannot be found with angle brackets, but can be found with quoted strings instead. Implements PR13201. llvm-svn: 160406
2012-07-18 07:19:16 +08:00
if (File) {
Factor out repeated code parsing and concatenating header-names from tokens. We now actually form an angled_string_literal token for a header name by concatenation rather than just working out what its contents would be. This substantially simplifies downstream processing and is necessary for C++20 header unit imports. llvm-svn: 356433
2019-03-19 09:51:19 +08:00
Diag(FilenameTok,
diag::err_pp_file_not_found_angled_include_not_fatal)
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
<< Filename << IsImportDecl
Factor out repeated code parsing and concatenating header-names from tokens. We now actually form an angled_string_literal token for a header name by concatenation rather than just working out what its contents would be. This substantially simplifies downstream processing and is necessary for C++20 header unit imports. llvm-svn: 356433
2019-03-19 09:51:19 +08:00
<< FixItHint::CreateReplacement(FilenameRange,
"\"" + Filename.str() + "\"");
Adding a fixit for includes that cannot be found with angle brackets, but can be found with quoted strings instead. Implements PR13201. llvm-svn: 160406
2012-07-18 07:19:16 +08:00
}
}
[modules] Rearrange preprocessor module visibility handling, no observable change intended. llvm-svn: 237331
2015-05-14 10:25:44 +08:00
Diagnose likely typos in #include directives. Summary: When someone writes #include "<some_file>" or #include " some_file " the compiler returns "file not fuond..." with fonts and quotes that may make it hard to see there are excess quotes or surprising bytes in the filename. Assuming that files are usually logically named and start and end with an alphanumeric character, we can check for the file's existence by stripping the non-alphanumeric leading or trailing characters. If the file is found, emit a non-fatal error with a FixItHint. Patch by Christy Lee! Reviewers: aaron.ballman, erikjv, rsmith Reviewed By: rsmith Subscribers: lebedev.ri, xbolva00, sammccall, modocache, erikjv, aaron.ballman, cfe-commits Differential Revision: https://reviews.llvm.org/D51333 llvm-svn: 342177
2018-09-14 05:10:08 +08:00
// Check for likely typos due to leading or trailing non-isAlphanumeric
// characters
r342177 introduced a hint in cases where an #included file is not found. It tries to find a suggestion by removing leading or trailing non-alphanumeric characters and checking if a matching file exists, then it reports an error like: include-likely-typo.c:3:10: error: '<empty_file_to_include.h>' file not found, did you mean 'empty_file_to_include.h'? ^~~~~~~~~~~~~~~~~~~~~~~~~~~ "empty_file_to_include.h" 1 error generated. However, if a hint is not found, the error message will show only the trimmed name we use to look for a hint, so: will result in: include-leading-nonalpha-no-suggest.c:3:10: fatal error: 'non_existing_file_to_include.h' file not found ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1 error generated. where the name reported after "fatal error:" doesn't match what the user wrote. Patch by Jorge Gorbe! Differential Revision: https://reviews.llvm.org/D52280 This change reports the original file name instead of the trimmed one when a suggestion is not found. llvm-svn: 342667
2018-09-21 01:21:56 +08:00
StringRef OriginalFilename = Filename;
[Preprocessor] Hide include typo correction behind SpellChecking. Summary: Similar to Sema typo correction, the Preprocessor typo correction should also be hidden behind the SpellChecking flag. Reviewers: sammccall Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D52778 llvm-svn: 343591
2018-10-02 21:59:49 +08:00
if (LangOpts.SpellChecking && !File) {
[Preprocessor] Fix a crash when handling non-alpha include header. Summary: the crash is casued by an assertion in StringRef. (llvm::StringRef::front() const: Assertion `!empty()' failed.) Reviewers: sammccall Subscribers: jsji, cfe-commits Differential Revision: https://reviews.llvm.org/D52721 llvm-svn: 343481
2018-10-01 22:38:43 +08:00
// A heuristic to correct a typo file name by removing leading and
// trailing non-isAlphanumeric characters.
auto CorrectTypoFilename = [](llvm::StringRef Filename) {
Filename = Filename.drop_until(isAlphanumeric);
while (!Filename.empty() && !isAlphanumeric(Filename.back())) {
Filename = Filename.drop_back();
}
return Filename;
};
[Preprocesssor] Filename should fall back to the written name when typo correction fails. Summary: The test is added in Testcase is at https://reviews.llvm.org/D52775. I tried to add the test to clang's code completion test, it doesn't reproduce the crash. Reviewers: sammccall, kristina Reviewed By: sammccall Subscribers: kristina, ilya-biryukov, ioeric, MaskRay, jkorous, arphaman, kadircet, cfe-commits Differential Revision: https://reviews.llvm.org/D52774 llvm-svn: 343592
2018-10-02 22:42:51 +08:00
StringRef TypoCorrectionName = CorrectTypoFilename(Filename);
[MSVC Compat] Fix typo correction for inclusion directives. In MSVC compatibility mode we were checking not the typo corrected filename but the original filename. Reviewers: christylee, compnerd Reviewed By: christylee Subscribers: jkorous, dexonsmith, sammccall, hokein, cfe-commits Differential Revision: https://reviews.llvm.org/D56631 llvm-svn: 351232
2019-01-16 04:08:23 +08:00
SmallString<128> NormalizedTypoCorrectionPath;
if (LangOpts.MSVCCompat) {
NormalizedTypoCorrectionPath = TypoCorrectionName.str();
#ifndef _WIN32
llvm::sys::path::native(NormalizedTypoCorrectionPath);
#endif
}
Diagnose likely typos in #include directives. Summary: When someone writes #include "<some_file>" or #include " some_file " the compiler returns "file not fuond..." with fonts and quotes that may make it hard to see there are excess quotes or surprising bytes in the filename. Assuming that files are usually logically named and start and end with an alphanumeric character, we can check for the file's existence by stripping the non-alphanumeric leading or trailing characters. If the file is found, emit a non-fatal error with a FixItHint. Patch by Christy Lee! Reviewers: aaron.ballman, erikjv, rsmith Reviewed By: rsmith Subscribers: lebedev.ri, xbolva00, sammccall, modocache, erikjv, aaron.ballman, cfe-commits Differential Revision: https://reviews.llvm.org/D51333 llvm-svn: 342177
2018-09-14 05:10:08 +08:00
File = LookupFile(
FilenameLoc,
[MSVC Compat] Fix typo correction for inclusion directives. In MSVC compatibility mode we were checking not the typo corrected filename but the original filename. Reviewers: christylee, compnerd Reviewed By: christylee Subscribers: jkorous, dexonsmith, sammccall, hokein, cfe-commits Differential Revision: https://reviews.llvm.org/D56631 llvm-svn: 351232
2019-01-16 04:08:23 +08:00
LangOpts.MSVCCompat ? NormalizedTypoCorrectionPath.c_str()
: TypoCorrectionName,
[Preprocesssor] Filename should fall back to the written name when typo correction fails. Summary: The test is added in Testcase is at https://reviews.llvm.org/D52775. I tried to add the test to clang's code completion test, it doesn't reproduce the crash. Reviewers: sammccall, kristina Reviewed By: sammccall Subscribers: kristina, ilya-biryukov, ioeric, MaskRay, jkorous, arphaman, kadircet, cfe-commits Differential Revision: https://reviews.llvm.org/D52774 llvm-svn: 343592
2018-10-02 22:42:51 +08:00
isAngled, LookupFrom, LookupFromFile, CurDir,
Diagnose likely typos in #include directives. Summary: When someone writes #include "<some_file>" or #include " some_file " the compiler returns "file not fuond..." with fonts and quotes that may make it hard to see there are excess quotes or surprising bytes in the filename. Assuming that files are usually logically named and start and end with an alphanumeric character, we can check for the file's existence by stripping the non-alphanumeric leading or trailing characters. If the file is found, emit a non-fatal error with a FixItHint. Patch by Christy Lee! Reviewers: aaron.ballman, erikjv, rsmith Reviewed By: rsmith Subscribers: lebedev.ri, xbolva00, sammccall, modocache, erikjv, aaron.ballman, cfe-commits Differential Revision: https://reviews.llvm.org/D51333 llvm-svn: 342177
2018-09-14 05:10:08 +08:00
Callbacks ? &SearchPath : nullptr,
[Preprocessor] Add a note with framework location for "file not found" error. When a framework with the same name is available at multiple framework search paths, we use the first matching location. If a framework at this location doesn't have all the headers, it can be confusing for developers because they see only an error `'Foo/Foo.h' file not found`, can find the complete framework with required header, and don't know the incomplete framework was used instead. Add a note explaining a framework without required header was found. Also mention framework directory path to make it easier to find the incomplete framework. rdar://problem/39246514 Reviewers: arphaman, erik.pilkington, jkorous Reviewed By: jkorous Subscribers: jkorous, dexonsmith, cfe-commits Differential Revision: https://reviews.llvm.org/D56561 llvm-svn: 353231
2019-02-06 06:34:55 +08:00
Callbacks ? &RelativePath : nullptr, &SuggestedModule, &IsMapped,
/*IsFrameworkFound=*/nullptr);
Diagnose likely typos in #include directives. Summary: When someone writes #include "<some_file>" or #include " some_file " the compiler returns "file not fuond..." with fonts and quotes that may make it hard to see there are excess quotes or surprising bytes in the filename. Assuming that files are usually logically named and start and end with an alphanumeric character, we can check for the file's existence by stripping the non-alphanumeric leading or trailing characters. If the file is found, emit a non-fatal error with a FixItHint. Patch by Christy Lee! Reviewers: aaron.ballman, erikjv, rsmith Reviewed By: rsmith Subscribers: lebedev.ri, xbolva00, sammccall, modocache, erikjv, aaron.ballman, cfe-commits Differential Revision: https://reviews.llvm.org/D51333 llvm-svn: 342177
2018-09-14 05:10:08 +08:00
if (File) {
Factor out repeated code parsing and concatenating header-names from tokens. We now actually form an angled_string_literal token for a header name by concatenation rather than just working out what its contents would be. This substantially simplifies downstream processing and is necessary for C++20 header unit imports. llvm-svn: 356433
2019-03-19 09:51:19 +08:00
auto Hint =
isAngled
? FixItHint::CreateReplacement(
FilenameRange, "<" + TypoCorrectionName.str() + ">")
: FixItHint::CreateReplacement(
FilenameRange, "\"" + TypoCorrectionName.str() + "\"");
Diagnose likely typos in #include directives. Summary: When someone writes #include "<some_file>" or #include " some_file " the compiler returns "file not fuond..." with fonts and quotes that may make it hard to see there are excess quotes or surprising bytes in the filename. Assuming that files are usually logically named and start and end with an alphanumeric character, we can check for the file's existence by stripping the non-alphanumeric leading or trailing characters. If the file is found, emit a non-fatal error with a FixItHint. Patch by Christy Lee! Reviewers: aaron.ballman, erikjv, rsmith Reviewed By: rsmith Subscribers: lebedev.ri, xbolva00, sammccall, modocache, erikjv, aaron.ballman, cfe-commits Differential Revision: https://reviews.llvm.org/D51333 llvm-svn: 342177
2018-09-14 05:10:08 +08:00
Diag(FilenameTok, diag::err_pp_file_not_found_typo_not_fatal)
[Preprocesssor] Filename should fall back to the written name when typo correction fails. Summary: The test is added in Testcase is at https://reviews.llvm.org/D52775. I tried to add the test to clang's code completion test, it doesn't reproduce the crash. Reviewers: sammccall, kristina Reviewed By: sammccall Subscribers: kristina, ilya-biryukov, ioeric, MaskRay, jkorous, arphaman, kadircet, cfe-commits Differential Revision: https://reviews.llvm.org/D52774 llvm-svn: 343592
2018-10-02 22:42:51 +08:00
<< OriginalFilename << TypoCorrectionName << Hint;
// We found the file, so set the Filename to the name after typo
// correction.
Filename = TypoCorrectionName;
Diagnose likely typos in #include directives. Summary: When someone writes #include "<some_file>" or #include " some_file " the compiler returns "file not fuond..." with fonts and quotes that may make it hard to see there are excess quotes or surprising bytes in the filename. Assuming that files are usually logically named and start and end with an alphanumeric character, we can check for the file's existence by stripping the non-alphanumeric leading or trailing characters. If the file is found, emit a non-fatal error with a FixItHint. Patch by Christy Lee! Reviewers: aaron.ballman, erikjv, rsmith Reviewed By: rsmith Subscribers: lebedev.ri, xbolva00, sammccall, modocache, erikjv, aaron.ballman, cfe-commits Differential Revision: https://reviews.llvm.org/D51333 llvm-svn: 342177
2018-09-14 05:10:08 +08:00
}
}
Adding a fixit for includes that cannot be found with angle brackets, but can be found with quoted strings instead. Implements PR13201. llvm-svn: 160406
2012-07-18 07:19:16 +08:00
// If the file is still not found, just go with the vanilla diagnostic
[Preprocessor] Add a note with framework location for "file not found" error. When a framework with the same name is available at multiple framework search paths, we use the first matching location. If a framework at this location doesn't have all the headers, it can be confusing for developers because they see only an error `'Foo/Foo.h' file not found`, can find the complete framework with required header, and don't know the incomplete framework was used instead. Add a note explaining a framework without required header was found. Also mention framework directory path to make it easier to find the incomplete framework. rdar://problem/39246514 Reviewers: arphaman, erik.pilkington, jkorous Reviewed By: jkorous Subscribers: jkorous, dexonsmith, cfe-commits Differential Revision: https://reviews.llvm.org/D56561 llvm-svn: 353231
2019-02-06 06:34:55 +08:00
if (!File) {
r342177 introduced a hint in cases where an #included file is not found. It tries to find a suggestion by removing leading or trailing non-alphanumeric characters and checking if a matching file exists, then it reports an error like: include-likely-typo.c:3:10: error: '<empty_file_to_include.h>' file not found, did you mean 'empty_file_to_include.h'? ^~~~~~~~~~~~~~~~~~~~~~~~~~~ "empty_file_to_include.h" 1 error generated. However, if a hint is not found, the error message will show only the trimmed name we use to look for a hint, so: will result in: include-leading-nonalpha-no-suggest.c:3:10: fatal error: 'non_existing_file_to_include.h' file not found ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1 error generated. where the name reported after "fatal error:" doesn't match what the user wrote. Patch by Jorge Gorbe! Differential Revision: https://reviews.llvm.org/D52280 This change reports the original file name instead of the trimmed one when a suggestion is not found. llvm-svn: 342667
2018-09-21 01:21:56 +08:00
Diag(FilenameTok, diag::err_pp_file_not_found) << OriginalFilename
Include full filename range for missing includes For the purpose of highlighting in an IDE. llvm-svn: 285057
2016-10-25 18:13:10 +08:00
<< FilenameRange;
[Preprocessor] Add a note with framework location for "file not found" error. When a framework with the same name is available at multiple framework search paths, we use the first matching location. If a framework at this location doesn't have all the headers, it can be confusing for developers because they see only an error `'Foo/Foo.h' file not found`, can find the complete framework with required header, and don't know the incomplete framework was used instead. Add a note explaining a framework without required header was found. Also mention framework directory path to make it easier to find the incomplete framework. rdar://problem/39246514 Reviewers: arphaman, erik.pilkington, jkorous Reviewed By: jkorous Subscribers: jkorous, dexonsmith, cfe-commits Differential Revision: https://reviews.llvm.org/D56561 llvm-svn: 353231
2019-02-06 06:34:55 +08:00
if (IsFrameworkFound) {
size_t SlashPos = OriginalFilename.find('/');
assert(SlashPos != StringRef::npos &&
"Include with framework name should have '/' in the filename");
StringRef FrameworkName = OriginalFilename.substr(0, SlashPos);
FrameworkCacheEntry &CacheEntry =
HeaderInfo.LookupFrameworkCache(FrameworkName);
assert(CacheEntry.Directory && "Found framework should be in cache");
Diag(FilenameTok, diag::note_pp_framework_without_header)
<< OriginalFilename.substr(SlashPos + 1) << FrameworkName
<< CacheEntry.Directory->getName();
}
}
Adding a fixit for includes that cannot be found with angle brackets, but can be found with quoted strings instead. Implements PR13201. llvm-svn: 160406
2012-07-18 07:19:16 +08:00
}
Move the module auto-import logic after the logic that allows a callback client to suggest an alternative search path and after we complain when the included file can't be found. The former can't be tested in isolation, the latter doesn't actually matter (because we won't make a module suggestion if no header is available). However, the flow is better this way. llvm-svn: 145502
2011-12-01 02:12:06 +08:00
}
[clang-cl, PCH] Implement support for MS-style PCH through headers Implement support for MS-style PCH through headers. This enables support for /Yc and /Yu where the through header is either on the command line or included in the source. It replaces the current support the requires the header also be specified with /FI. This change adds a -cc1 option -pch-through-header that is used to either start or stop compilation during PCH create or use. When creating a PCH, the compilation ends after compilation of the through header. When using a PCH, tokens are skipped until after the through header is seen. Patch By: mikerice Differential Revision: https://reviews.llvm.org/D46652 llvm-svn: 336379
2018-07-06 01:22:13 +08:00
if (usingPCHWithThroughHeader() && SkippingUntilPCHThroughHeader) {
if (isPCHThroughHeader(File))
SkippingUntilPCHThroughHeader = false;
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
return {ImportAction::None};
[clang-cl, PCH] Implement support for MS-style PCH through headers Implement support for MS-style PCH through headers. This enables support for /Yc and /Yu where the through header is either on the command line or included in the source. It replaces the current support the requires the header also be specified with /FI. This change adds a -cc1 option -pch-through-header that is used to either start or stop compilation during PCH create or use. When creating a PCH, the compilation ends after compilation of the through header. When using a PCH, tokens are skipped until after the through header is seen. Patch By: mikerice Differential Revision: https://reviews.llvm.org/D46652 llvm-svn: 336379
2018-07-06 01:22:13 +08:00
}
Refactor handling of #include directives to cleanly separate the "skipped header because it should be imported as a module" cases from the "skipped header because of some other reason" cases. llvm-svn: 356704
2019-03-22 03:44:17 +08:00
// Should we enter the source file? Set to Skip if either the source file is
[modules] Refactor and simplify #include handling. Fix a tiny bug where we'd try to load a module file for the module we're in the middle of building. llvm-svn: 237552
2015-05-18 12:45:41 +08:00
// known to have no effect beyond its effect on module visibility -- that is,
Refactor handling of #include directives to cleanly separate the "skipped header because it should be imported as a module" cases from the "skipped header because of some other reason" cases. llvm-svn: 356704
2019-03-22 03:44:17 +08:00
// if it's got an include guard that is already defined, set to Import if it
// is a modular header we've already built and should import.
enum { Enter, Import, Skip, IncludeLimitReached } Action = Enter;
[modules] Refactor and simplify #include handling. Fix a tiny bug where we'd try to load a module file for the module we're in the middle of building. llvm-svn: 237552
2015-05-18 12:45:41 +08:00
[libclang] Introduce a new parsing option 'CXTranslationUnit_SingleFileParse' that puts preprocessor in a mode for parsing a single file only. This is useful for parsing a single file, as a fast/inaccurate 'mode' that can still provide declarations from the file, like the classes and their methods. llvm-svn: 305044
2017-06-09 09:20:48 +08:00
if (PPOpts->SingleFileParseMode)
Refactor handling of #include directives to cleanly separate the "skipped header because it should be imported as a module" cases from the "skipped header because of some other reason" cases. llvm-svn: 356704
2019-03-22 03:44:17 +08:00
Action = IncludeLimitReached;
[libclang] Introduce a new parsing option 'CXTranslationUnit_SingleFileParse' that puts preprocessor in a mode for parsing a single file only. This is useful for parsing a single file, as a fast/inaccurate 'mode' that can still provide declarations from the file, like the classes and their methods. llvm-svn: 305044
2017-06-09 09:20:48 +08:00
[Preprocessor] Don't avoid entering included files after hitting a fatal error. Change in r337953 violated the contract for `CXTranslationUnit_KeepGoing`: > Do not stop processing when fatal errors are encountered. Use different approach to fix long processing times with multiple inclusion cycles. Instead of stopping preprocessing for fatal errors, do this after reaching the max allowed include depth and only for the files that were processed already. It is likely but not guaranteed those files cause a cycle. rdar://problem/46108547 Reviewers: erik.pilkington, arphaman Reviewed By: erik.pilkington Subscribers: jkorous, dexonsmith, ilya-biryukov, Dmitry.Kozhevnikov Differential Revision: https://reviews.llvm.org/D55095 llvm-svn: 348641
2018-12-08 04:29:54 +08:00
// If we've reached the max allowed include depth, it is usually due to an
// include cycle. Don't enter already processed files again as it can lead to
// reaching the max allowed include depth again.
Refactor handling of #include directives to cleanly separate the "skipped header because it should be imported as a module" cases from the "skipped header because of some other reason" cases. llvm-svn: 356704
2019-03-22 03:44:17 +08:00
if (Action == Enter && HasReachedMaxIncludeDepth && File &&
[Preprocessor] Don't avoid entering included files after hitting a fatal error. Change in r337953 violated the contract for `CXTranslationUnit_KeepGoing`: > Do not stop processing when fatal errors are encountered. Use different approach to fix long processing times with multiple inclusion cycles. Instead of stopping preprocessing for fatal errors, do this after reaching the max allowed include depth and only for the files that were processed already. It is likely but not guaranteed those files cause a cycle. rdar://problem/46108547 Reviewers: erik.pilkington, arphaman Reviewed By: erik.pilkington Subscribers: jkorous, dexonsmith, ilya-biryukov, Dmitry.Kozhevnikov Differential Revision: https://reviews.llvm.org/D55095 llvm-svn: 348641
2018-12-08 04:29:54 +08:00
HeaderInfo.getFileInfo(File).NumIncludes)
Refactor handling of #include directives to cleanly separate the "skipped header because it should be imported as a module" cases from the "skipped header because of some other reason" cases. llvm-svn: 356704
2019-03-22 03:44:17 +08:00
Action = IncludeLimitReached;
[Preprocessor] Stop entering included files after hitting a fatal error. Fixes a problem when we have multiple inclusion cycles and try to enumerate all possible ways to reach the max inclusion depth. rdar://problem/38871876 Reviewers: bruno, rsmith, jkorous, aaron.ballman Reviewed By: bruno, jkorous, aaron.ballman Subscribers: dexonsmith, cfe-commits Differential Revision: https://reviews.llvm.org/D48786 llvm-svn: 337953
2018-07-26 03:16:26 +08:00
[modules] Refactor and simplify #include handling. Fix a tiny bug where we'd try to load a module file for the module we're in the middle of building. llvm-svn: 237552
2015-05-18 12:45:41 +08:00
// Determine whether we should try to import the module for this #include, if
// there is one. Don't do so if precompiled module support is disabled or we
// are processing this module textually (because we're building the module).
Refactor handling of #include directives to cleanly separate the "skipped header because it should be imported as a module" cases from the "skipped header because of some other reason" cases. llvm-svn: 356704
2019-03-22 03:44:17 +08:00
if (Action == Enter && File && SuggestedModule && getLangOpts().Modules &&
[Modules] Extend -fmodule-name semantic for frameworks with private modules Assume Foo.framework with two module maps and two modules Foo and Foo_Private. Framework authors need to skip building both Foo and Foo_Private when using -fmodule-name=Foo, since both are part of the framework and used interchangeably during compilation. rdar://problem/37500098 llvm-svn: 325305
2018-02-16 08:12:57 +08:00
!isForModuleBuilding(SuggestedModule.getModule(),
[Modules] Honor -fmodule-name when handling private framework modules When skipping building the module for a private framework module, LangOpts.CurrentModule isn't enough for implict modules builds; for instance, in case a private module is built while building a public one, LangOpts.CurrentModule doesn't reflect the -fmodule-name being passed down, but instead the module name which triggered the build. Store the actual -fmodule-name in LangOpts.ModuleName and actually check a name was provided during compiler invocation in order to skip building the private module. rdar://problem/38434694 llvm-svn: 328053
2018-03-21 06:36:39 +08:00
getLangOpts().CurrentModule,
getLangOpts().ModuleName)) {
[modules] PR20507: Avoid silent textual inclusion. Summary: If a module was unavailable (either a missing requirement on the module being imported, or a missing file anywhere in the top-level module (and not dominated by an unsatisfied `requires`)), we would silently treat inclusions as textual. This would cause all manner of crazy and confusing errors (and would also silently "work" sometimes, making the problem difficult to track down). I'm really not a fan of the `M->isAvailable(getLangOpts(), getTargetInfo(), Requirement, MissingHeader)` function; it seems to do too many things at once, but for now I've done things in a sort of awkward way. The changes to test/Modules/Inputs/declare-use/module.map were necessitated because the thing that was meant to be tested there (introduced in r197805) was predicated on silently falling back to textual inclusion, which we no longer do. The changes to test/Modules/Inputs/macro-reexport/module.modulemap are just an overlooked missing header that seems to have been missing since this code was committed (r213922), which is now caught. Reviewers: rsmith, benlangmuir, djasper Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D10423 llvm-svn: 245228
2015-08-18 00:39:30 +08:00
// If this include corresponds to a module but that module is
// unavailable, diagnose the situation and bail out.
[modules] When an incompatible module file is explicitly provided for a module, and we fall back to textual inclusion, don't require the module as a whole to be marked available; it's OK if some other file in the same module is missing, just as it would be if the header were explicitly marked textual. llvm-svn: 266113
2016-04-13 03:58:30 +08:00
// FIXME: Remove this; loadModule does the same check (but produces
// slightly worse diagnostics).
Factor out and unify emission of "module is unavailable" diagnostics. Inspired by post-commit review of r304190. llvm-svn: 304728
2017-06-06 02:57:56 +08:00
if (checkModuleIsAvailable(getLangOpts(), getTargetInfo(), getDiagnostics(),
SuggestedModule.getModule())) {
[modules] PR20507: Avoid silent textual inclusion. Summary: If a module was unavailable (either a missing requirement on the module being imported, or a missing file anywhere in the top-level module (and not dominated by an unsatisfied `requires`)), we would silently treat inclusions as textual. This would cause all manner of crazy and confusing errors (and would also silently "work" sometimes, making the problem difficult to track down). I'm really not a fan of the `M->isAvailable(getLangOpts(), getTargetInfo(), Requirement, MissingHeader)` function; it seems to do too many things at once, but for now I've done things in a sort of awkward way. The changes to test/Modules/Inputs/declare-use/module.map were necessitated because the thing that was meant to be tested there (introduced in r197805) was predicated on silently falling back to textual inclusion, which we no longer do. The changes to test/Modules/Inputs/macro-reexport/module.modulemap are just an overlooked missing header that seems to have been missing since this code was committed (r213922), which is now caught. Reviewers: rsmith, benlangmuir, djasper Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D10423 llvm-svn: 245228
2015-08-18 00:39:30 +08:00
Diag(FilenameTok.getLocation(),
diag::note_implicit_top_level_module_import_here)
Factor out and unify emission of "module is unavailable" diagnostics. Inspired by post-commit review of r304190. llvm-svn: 304728
2017-06-06 02:57:56 +08:00
<< SuggestedModule.getModule()->getTopLevelModuleName();
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
return {ImportAction::None};
[modules] PR20507: Avoid silent textual inclusion. Summary: If a module was unavailable (either a missing requirement on the module being imported, or a missing file anywhere in the top-level module (and not dominated by an unsatisfied `requires`)), we would silently treat inclusions as textual. This would cause all manner of crazy and confusing errors (and would also silently "work" sometimes, making the problem difficult to track down). I'm really not a fan of the `M->isAvailable(getLangOpts(), getTargetInfo(), Requirement, MissingHeader)` function; it seems to do too many things at once, but for now I've done things in a sort of awkward way. The changes to test/Modules/Inputs/declare-use/module.map were necessitated because the thing that was meant to be tested there (introduced in r197805) was predicated on silently falling back to textual inclusion, which we no longer do. The changes to test/Modules/Inputs/macro-reexport/module.modulemap are just an overlooked missing header that seems to have been missing since this code was committed (r213922), which is now caught. Reviewers: rsmith, benlangmuir, djasper Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D10423 llvm-svn: 245228
2015-08-18 00:39:30 +08:00
}
Switch the module-loading interfaces and parser from a simple top-level module name to a module path (e.g., std.vector). We're still missing a number of pieces for this actually to do something. llvm-svn: 145462
2011-11-30 08:36:36 +08:00
// Compute the module access path corresponding to this module.
// FIXME: Should we have a second loadModule() overload to avoid this
// extra lookup step?
Remove useless 'llvm::' qualifier from names like StringRef and others that are brought into 'clang' namespace by clang/Basic/LLVM.h llvm-svn: 172323
2013-01-13 03:30:44 +08:00
SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
This patch adds new private headers to the module map. Private headers may be included from within the module, but not from outside the module. llvm-svn: 184471
2013-06-21 05:14:14 +08:00
for (Module *Mod = SuggestedModule.getModule(); Mod; Mod = Mod->Parent)
Switch the module-loading interfaces and parser from a simple top-level module name to a module path (e.g., std.vector). We're still missing a number of pieces for this actually to do something. llvm-svn: 145462
2011-11-30 08:36:36 +08:00
Path.push_back(std::make_pair(getIdentifierInfo(Mod->Name),
FilenameTok.getLocation()));
std::reverse(Path.begin(), Path.end());
Introduce an opt-in warning indicating when the compiler is treating an #include/#import as a module import. llvm-svn: 145500
2011-12-01 02:02:36 +08:00
// Warn that we're replacing the include/import with a module import.
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
if (!IsImportDecl)
diagnoseAutoModuleImport(*this, StartLoc, IncludeTok, Path, CharEnd);
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
[modules] Remove dead code from Module for tracking macro import locations. llvm-svn: 236376
2015-05-02 10:08:26 +08:00
// Load the module to import its macros. We'll make the declarations
When we hit a #include directive that maps to a module import, emit a token representing the module import rather than making the module immediately visible. This serves two goals: * It avoids making declarations in the module visible prematurely, if we walk past the #include during a tentative parse, for instance, and * It gives a diagnostic (although, admittedly, not a very nice one) if a header with a corresponding module is included anywhere other than at the top level. llvm-svn: 194782
2013-11-15 12:24:58 +08:00
// visible when the parser gets here.
[modules] Rearrange preprocessor module visibility handling, no observable change intended. llvm-svn: 237331
2015-05-14 10:25:44 +08:00
// FIXME: Pass SuggestedModule in here rather than converting it to a path
// and making the module loader convert it back again.
[modules] Remove dead code from Module for tracking macro import locations. llvm-svn: 236376
2015-05-02 10:08:26 +08:00
ModuleLoadResult Imported = TheModuleLoader.loadModule(
IncludeTok.getLocation(), Path, Module::Hidden,
/*IsIncludeDirective=*/true);
[C++11] Use 'nullptr'. Lex edition. llvm-svn: 209083
2014-05-18 07:10:59 +08:00
assert((Imported == nullptr || Imported == SuggestedModule.getModule()) &&
Add an assertion to make sure the implicitly imported module is the same as the suggested one when looking up the include filename. llvm-svn: 164872
2012-09-29 09:06:01 +08:00
"the imported module is different than the suggested one");
[modules] If we hit a failure while loading a PCH/module, abort parsing instead of trying to continue in an invalid state. Also don't let libclang create a PCH with such an error. Fixes rdar://13953768 llvm-svn: 182629
2013-05-24 13:44:08 +08:00
Refactor handling of #include directives to cleanly separate the "skipped header because it should be imported as a module" cases from the "skipped header because of some other reason" cases. llvm-svn: 356704
2019-03-22 03:44:17 +08:00
if (Imported) {
Action = Import;
} else if (Imported.isMissingExpected()) {
[modules] Refactor and simplify #include handling. Fix a tiny bug where we'd try to load a module file for the module we're in the middle of building. llvm-svn: 237552
2015-05-18 12:45:41 +08:00
// We failed to find a submodule that we assumed would exist (because it
// was in the directory of an umbrella header, for instance), but no
Revert r288626, which reverts r288449. Original commit message: Recover better from an incompatible .pcm file being provided by -fmodule-file=. We try to include the headers of the module textually in this case, still enforcing the modules semantic rules. In order to make that work, we need to still track that we're entering and leaving the module. Also, if the module was also marked as unavailable (perhaps because it was missing a file), we shouldn't mark the module unavailable -- we don't need the module to be complete if we're going to enter it textually. llvm-svn: 288741
2016-12-06 08:40:17 +08:00
// actual module containing it exists (because the umbrella header is
[modules] Refactor and simplify #include handling. Fix a tiny bug where we'd try to load a module file for the module we're in the middle of building. llvm-svn: 237552
2015-05-18 12:45:41 +08:00
// incomplete). Treat this as a textual inclusion.
SuggestedModule = ModuleMap::KnownHeader();
Revert r288626, which reverts r288449. Original commit message: Recover better from an incompatible .pcm file being provided by -fmodule-file=. We try to include the headers of the module textually in this case, still enforcing the modules semantic rules. In order to make that work, we need to still track that we're entering and leaving the module. Also, if the module was also marked as unavailable (perhaps because it was missing a file), we shouldn't mark the module unavailable -- we don't need the module to be complete if we're going to enter it textually. llvm-svn: 288741
2016-12-06 08:40:17 +08:00
} else if (Imported.isConfigMismatch()) {
// On a configuration mismatch, enter the header textually. We still know
// that it's part of the corresponding module.
[modules] Refactor and simplify #include handling. Fix a tiny bug where we'd try to load a module file for the module we're in the middle of building. llvm-svn: 237552
2015-05-18 12:45:41 +08:00
} else {
// We hit an error processing the import. Bail out.
if (hadModuleLoaderFatalFailure()) {
// With a fatal failure in the module loader, we abort parsing.
Token &Result = IncludeTok;
PTH-- Remove feature entirely- When debugging a boost build with a modified version of Clang, I discovered that the PTH implementation stores TokenKind in 8 bits. However, we currently have 368 TokenKinds. The result is that the value gets truncated and the wrong token gets picked up when including PTH files. It seems that this will go wrong every time someone uses a token that uses the 9th bit. Upon asking on IRC, it was brought up that this was a highly experimental features that was considered a failure. I discovered via googling that BoostBuild (mostly Boost.Math) is the only user of this feature, using the CC1 flag directly. I believe that this can be transferred over to normal PCH with minimal effort: https://github.com/boostorg/build/issues/367 Based on advice on IRC and research showing that this is a nearly completely unused feature, this patch removes it entirely. Note: I considered leaving the build-flags in place and making them emit an error/warning, however since I've basically identified and warned the only user, it seemed better to just remove them. Differential Revision: https://reviews.llvm.org/D54547 Change-Id: If32744275ef1f585357bd6c1c813d96973c4d8d9 llvm-svn: 348266
2018-12-04 22:34:09 +08:00
assert(CurLexer && "#include but no current lexer set!");
Result.startToken();
CurLexer->FormTokenWithChars(Result, CurLexer->BufferEnd, tok::eof);
CurLexer->cutOffLexing();
When we hit a #include directive that maps to a module import, emit a token representing the module import rather than making the module immediately visible. This serves two goals: * It avoids making declarations in the module visible prematurely, if we walk past the #include during a tentative parse, for instance, and * It gives a diagnostic (although, admittedly, not a very nice one) if a header with a corresponding module is included anywhere other than at the top level. llvm-svn: 194782
2013-11-15 12:24:58 +08:00
}
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
return {ImportAction::None};
For PPCallbacks::InclusionDirective() add a parameter for the module, whenever an inclusion directive was automatically turned into a module import, and PPCallbacks::moduleImport() for an explicit module import. llvm-svn: 164874
2012-09-29 09:06:10 +08:00
}
}
[modules] When we #include a local submodule header that we've already built, and it has an include guard, produce callbacks for a module import, not for a skipped non-modular header. Fixes -E output when preprocessing a module to list these cases as a module import, rather than suppressing the #include and losing the import side effect. llvm-svn: 304183
2017-05-30 10:03:19 +08:00
// The #included file will be considered to be a system header if either it is
// in a system include directory, or if the #includer is a system include
// header.
SrcMgr::CharacteristicKind FileCharacter =
SourceMgr.getFileCharacteristic(FilenameTok.getLocation());
if (File)
FileCharacter = std::max(HeaderInfo.getFileDirFlavor(File), FileCharacter);
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
// If this is a '#import' or an import-declaration, don't re-enter the file.
//
// FIXME: If we have a suggested module for a '#include', and we've already
// visited this file, don't bother entering it again. We know it has no
// further effect.
bool EnterOnce =
IsImportDecl ||
IncludeTok.getIdentifierInfo()->getPPKeywordID() == tok::pp_import;
[modules] When we #include a local submodule header that we've already built, and it has an include guard, produce callbacks for a module import, not for a skipped non-modular header. Fixes -E output when preprocessing a module to list these cases as a module import, rather than suppressing the #include and losing the import side effect. llvm-svn: 304183
2017-05-30 10:03:19 +08:00
// Ask HeaderInfo if we should enter this #include file. If not, #including
// this file will have no effect.
Refactor handling of #include directives to cleanly separate the "skipped header because it should be imported as a module" cases from the "skipped header because of some other reason" cases. llvm-svn: 356704
2019-03-22 03:44:17 +08:00
if (Action == Enter && File &&
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
!HeaderInfo.ShouldEnterIncludeFile(*this, File, EnterOnce,
[modules] When we #include a local submodule header that we've already built, and it has an include guard, produce callbacks for a module import, not for a skipped non-modular header. Fixes -E output when preprocessing a module to list these cases as a module import, rather than suppressing the #include and losing the import side effect. llvm-svn: 304183
2017-05-30 10:03:19 +08:00
getLangOpts().Modules,
SuggestedModule.getModule())) {
Refactor handling of #include directives to cleanly separate the "skipped header because it should be imported as a module" cases from the "skipped header because of some other reason" cases. llvm-svn: 356704
2019-03-22 03:44:17 +08:00
// Even if we've already preprocessed this header once and know that we
// don't need to see its contents again, we still need to import it if it's
// modular because we might not have imported it from this submodule before.
//
// FIXME: We don't do this when compiling a PCH because the AST
// serialization layer can't cope with it. This means we get local
// submodule visibility semantics wrong in that case.
Action = (SuggestedModule && !getLangOpts().CompilingPCH) ? Import : Skip;
[modules] When we #include a local submodule header that we've already built, and it has an include guard, produce callbacks for a module import, not for a skipped non-modular header. Fixes -E output when preprocessing a module to list these cases as a module import, rather than suppressing the #include and losing the import side effect. llvm-svn: 304183
2017-05-30 10:03:19 +08:00
}
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
if (Callbacks && !IsImportDecl) {
[modules] Refactor and simplify #include handling. Fix a tiny bug where we'd try to load a module file for the module we're in the middle of building. llvm-svn: 237552
2015-05-18 12:45:41 +08:00
// Notify the callback object that we've seen an inclusion directive.
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
// FIXME: Use a different callback for a pp-import?
[modules] Refactor and simplify #include handling. Fix a tiny bug where we'd try to load a module file for the module we're in the middle of building. llvm-svn: 237552
2015-05-18 12:45:41 +08:00
Callbacks->InclusionDirective(
HashLoc, IncludeTok,
LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled,
FilenameRange, File, SearchPath, RelativePath,
Refactor handling of #include directives to cleanly separate the "skipped header because it should be imported as a module" cases from the "skipped header because of some other reason" cases. llvm-svn: 356704
2019-03-22 03:44:17 +08:00
Action == Import ? SuggestedModule.getModule() : nullptr,
FileCharacter);
if (Action == Skip)
[modules] When we #include a local submodule header that we've already built, and it has an include guard, produce callbacks for a module import, not for a skipped non-modular header. Fixes -E output when preprocessing a module to list these cases as a module import, rather than suppressing the #include and losing the import side effect. llvm-svn: 304183
2017-05-30 10:03:19 +08:00
Callbacks->FileSkipped(*File, FilenameTok, FileCharacter);
Add an experimental flag -fauto-module-import that automatically turns #include or #import direcctives of framework headers into module imports of the corresponding framework module. llvm-svn: 139860
2011-09-16 06:00:41 +08:00
}
[modules] Refactor and simplify #include handling. Fix a tiny bug where we'd try to load a module file for the module we're in the middle of building. llvm-svn: 237552
2015-05-18 12:45:41 +08:00
if (!File)
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
return {ImportAction::None};
// If this is a C++20 pp-import declaration, diagnose if we didn't find any
// module corresponding to the named header.
if (IsImportDecl && !SuggestedModule) {
Diag(FilenameTok, diag::err_header_import_not_header_unit)
<< OriginalFilename << File->getName();
return {ImportAction::None};
}
Revert r237609 for now. glibc's headers use __need_* macros to selectively export parts of themselves to each other. This requires us to enter those files repeatedly when building a glibc module. This can be unreverted once we have a better mechanism to deal with that non-modular aspect of glibc (possibly some way to mark a header as "textual if this macro is defined"). llvm-svn: 237718
2015-05-20 03:58:11 +08:00
Use the name of the file on disk to issue a new diagnostic about non-portable #include and #import paths. Differential Revision: http://reviews.llvm.org/D19843 Corresponding LLVM change: http://reviews.llvm.org/D19842 Re-commit of r272562 after addressing clang-x86-win2008-selfhost failure. llvm-svn: 272584
2016-06-14 04:40:21 +08:00
// Issue a diagnostic if the name of the file on disk has a different case
// than the one we're about to open.
const bool CheckIncludePathPortability =
Preprocessor: Suppress -Wnonportable-include-path for header maps If a file search involves a header map, suppress -Wnonportable-include-path. It's firing lots of false positives for framework authors internally, and it's not trivial to fix. Consider a framework called "Foo" with a main (installed) framework header "Foo/Foo.h". It's atypical for "Foo.h" to actually live inside a directory called "Foo" in the source repository. Instead, the build system generates a header map while building the framework. If Foo.h lives at the top-level of the source repository (common), and the git repo is called ssh://some.url/foo.git, then the header map will have something like: Foo/Foo.h -> /Users/myname/code/foo/Foo.h where "/Users/myname/code/foo" is the clone of ssh://some.url/foo.git. After #import <Foo/Foo.h>, the current implementation of -Wnonportable-include-path will falsely assume that Foo.h was found in a nonportable way, because of the name of the git clone (.../foo/Foo.h). However, that directory name was not involved in the header search at all. This commit adds an extra parameter to Preprocessor::LookupFile and HeaderSearch::LookupFile to track if the search used a header map, making it easy to suppress the warning. Longer term, once we find a way to avoid the false positive, we should turn the warning back on. rdar://problem/28863903 llvm-svn: 301592
2017-04-28 05:41:51 +08:00
!IsMapped && File && !File->tryGetRealPathName().empty();
Use the name of the file on disk to issue a new diagnostic about non-portable #include and #import paths. Differential Revision: http://reviews.llvm.org/D19843 Corresponding LLVM change: http://reviews.llvm.org/D19842 Re-commit of r272562 after addressing clang-x86-win2008-selfhost failure. llvm-svn: 272584
2016-06-14 04:40:21 +08:00
if (CheckIncludePathPortability) {
StringRef Name = LangOpts.MSVCCompat ? NormalizedPath.str() : Filename;
StringRef RealPathName = File->tryGetRealPathName();
SmallVector<StringRef, 16> Components(llvm::sys::path::begin(Name),
llvm::sys::path::end(Name));
if (trySimplifyPath(Components, RealPathName)) {
SmallString<128> Path;
Path.reserve(Name.size()+2);
Path.push_back(isAngled ? '<' : '"');
Fix for pr31836 - pp_nonportable_path on absolute paths: broken delimiters Summary: This is a patch for PR31836. As the bug replaces the path separators in the included file name with the characters following them, the test script makes sure that there's no "Ccase-insensitive-include-pr31836.h" in the warning message. Reviewers: rsmith, eric_niebler Reviewed By: eric_niebler Subscribers: karies, cfe-commits Differential Revision: https://reviews.llvm.org/D30000 llvm-svn: 295779
2017-02-22 06:30:55 +08:00
bool isLeadingSeparator = llvm::sys::path::is_absolute(Name);
Use the name of the file on disk to issue a new diagnostic about non-portable #include and #import paths. Differential Revision: http://reviews.llvm.org/D19843 Corresponding LLVM change: http://reviews.llvm.org/D19842 Re-commit of r272562 after addressing clang-x86-win2008-selfhost failure. llvm-svn: 272584
2016-06-14 04:40:21 +08:00
for (auto Component : Components) {
Fix for pr31836 - pp_nonportable_path on absolute paths: broken delimiters Summary: This is a patch for PR31836. As the bug replaces the path separators in the included file name with the characters following them, the test script makes sure that there's no "Ccase-insensitive-include-pr31836.h" in the warning message. Reviewers: rsmith, eric_niebler Reviewed By: eric_niebler Subscribers: karies, cfe-commits Differential Revision: https://reviews.llvm.org/D30000 llvm-svn: 295779
2017-02-22 06:30:55 +08:00
if (isLeadingSeparator)
isLeadingSeparator = false;
else
Path.append(Component);
Use the name of the file on disk to issue a new diagnostic about non-portable #include and #import paths. Differential Revision: http://reviews.llvm.org/D19843 Corresponding LLVM change: http://reviews.llvm.org/D19842 Re-commit of r272562 after addressing clang-x86-win2008-selfhost failure. llvm-svn: 272584
2016-06-14 04:40:21 +08:00
// Append the separator the user used, or the close quote
Path.push_back(
Path.size() <= Filename.size() ? Filename[Path.size()-1] :
(isAngled ? '>' : '"'));
}
// For user files and known standard headers, by default we issue a diagnostic.
// For other system headers, we don't. They can be controlled separately.
auto DiagId = (FileCharacter == SrcMgr::C_User || warnByDefaultOnWrongCase(Name)) ?
diag::pp_nonportable_path : diag::pp_nonportable_system_path;
Remove unnecessary std::string construction llvm-svn: 295083
2017-02-15 02:38:40 +08:00
Diag(FilenameTok, DiagId) << Path <<
Factor out repeated code parsing and concatenating header-names from tokens. We now actually form an angled_string_literal token for a header name by concatenation rather than just working out what its contents would be. This substantially simplifies downstream processing and is necessary for C++20 header unit imports. llvm-svn: 356433
2019-03-19 09:51:19 +08:00
FixItHint::CreateReplacement(FilenameRange, Path);
Use the name of the file on disk to issue a new diagnostic about non-portable #include and #import paths. Differential Revision: http://reviews.llvm.org/D19843 Corresponding LLVM change: http://reviews.llvm.org/D19842 Re-commit of r272562 after addressing clang-x86-win2008-selfhost failure. llvm-svn: 272584
2016-06-14 04:40:21 +08:00
}
}
Refactor handling of #include directives to cleanly separate the "skipped header because it should be imported as a module" cases from the "skipped header because of some other reason" cases. llvm-svn: 356704
2019-03-22 03:44:17 +08:00
switch (Action) {
case Skip:
// If we don't need to enter the file, stop now.
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
return {ImportAction::None};
Refactor handling of #include directives to cleanly separate the "skipped header because it should be imported as a module" cases from the "skipped header because of some other reason" cases. llvm-svn: 356704
2019-03-22 03:44:17 +08:00
case IncludeLimitReached:
// If we reached our include limit and don't want to enter any more files,
// don't go any further.
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
return {ImportAction::None};
Refactor handling of #include directives to cleanly separate the "skipped header because it should be imported as a module" cases from the "skipped header because of some other reason" cases. llvm-svn: 356704
2019-03-22 03:44:17 +08:00
case Import: {
[modules] Rearrange preprocessor module visibility handling, no observable change intended. llvm-svn: 237331
2015-05-14 10:25:44 +08:00
// If this is a module import, make it visible if needed.
Refactor handling of #include directives to cleanly separate the "skipped header because it should be imported as a module" cases from the "skipped header because of some other reason" cases. llvm-svn: 356704
2019-03-22 03:44:17 +08:00
Module *M = SuggestedModule.getModule();
assert(M && "no module to import");
PCH: fix a regression that reports a module is defined in both pch and pcm. In r276159, we started to say that a module X is defined in a pch if we specify -fmodule-name when building the pch. This caused a regression that reports module X is defined in both pch and pcm if we generate the pch with -fmodule-name=X and then in a separate clang invocation, we include the pch and also import X.pcm. This patch adds an option CompilingPCH similar to CompilingModule. When we use -fmodule-name=X while building a pch, modular headers in X will be textually included and the compiler knows that we are not building module X, so we don't put module X in SUBMODULE_DEFINITION of the pch. Differential Revision: http://reviews.llvm.org/D28415 llvm-svn: 291465
2017-01-10 03:20:18 +08:00
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
makeModuleVisible(M, EndLoc);
[modules] Rearrange preprocessor module visibility handling, no observable change intended. llvm-svn: 237331
2015-05-14 10:25:44 +08:00
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
if (IncludeTok.getIdentifierInfo()->getPPKeywordID() ==
Refactor handling of #include directives to cleanly separate the "skipped header because it should be imported as a module" cases from the "skipped header because of some other reason" cases. llvm-svn: 356704
2019-03-22 03:44:17 +08:00
tok::pp___include_macros)
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
return {ImportAction::None};
return {ImportAction::ModuleImport, M};
add a PPCallback handler for a skipped #include, patch by Zhanyong Wan! llvm-svn: 101813
2010-04-20 04:44:31 +08:00
}
Refactor handling of #include directives to cleanly separate the "skipped header because it should be imported as a module" cases from the "skipped header because of some other reason" cases. llvm-svn: 356704
2019-03-22 03:44:17 +08:00
case Enter:
break;
}
Don't apply the include depth limit until we actually decide to enter the file. NFC unless a skipped #include is found at the final permitted #include level. llvm-svn: 356432
2019-03-19 09:51:17 +08:00
// Check that we don't have infinite #include recursion.
if (IncludeMacroStack.size() == MaxAllowedIncludeStackDepth-1) {
Diag(FilenameTok, diag::err_pp_include_too_deep);
HasReachedMaxIncludeDepth = true;
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
return {ImportAction::None};
Don't apply the include depth limit until we actually decide to enter the file. NFC unless a skipped #include is found at the final permitted #include level. llvm-svn: 356432
2019-03-19 09:51:17 +08:00
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Look up the file, create a File ID for it.
Factor out repeated code parsing and concatenating header-names from tokens. We now actually form an angled_string_literal token for a header name by concatenation rather than just working out what its contents would be. This substantially simplifies downstream processing and is necessary for C++20 header unit imports. llvm-svn: 356433
2019-03-19 09:51:19 +08:00
SourceLocation IncludePos = FilenameTok.getLocation();
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
// If the filename string was the result of macro expansions, set the include
// position on the file where it will be included and after the expansions.
if (IncludePos.isMacroID())
PR37189 Fix incorrect end source location and spelling for a split '>>' token. When a '>>' token is split into two '>' tokens (in C++11 onwards), or (as an extension) when we do the same for other tokens starting with a '>', we can't just use a location pointing to the first '>' as the location of the split token, because that would result in our miscomputing the length and spelling for the token. As a consequence, for example, a refactoring replacing 'A<X>' with something else would sometimes replace one character too many, and similarly diagnostics highlighting a template-id source range would highlight one character too many. Fix this by creating an expansion range covering the first character of the '>>' token, whose spelling is '>'. For this to work, we generalize the expansion range of a macro FileID to be either a token range (the common case) or a character range (used in this new case). llvm-svn: 331155
2018-04-30 13:25:48 +08:00
IncludePos = SourceMgr.getExpansionRange(IncludePos).getEnd();
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
FileID FID = SourceMgr.createFileID(File, IncludePos, FileCharacter);
Replace double negation of !FileID.isInvalid() with FileID.isValid(). +couple more of double-negated !SourceLocation.isInvalid() unfixed in r249228. llvm-svn: 249235
2015-10-03 18:46:20 +08:00
assert(FID.isValid() && "Expected valid file ID");
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Generate a marker token when entering or leaving a submodule when building a module. Use the marker to diagnose cases where we try to transition between submodules when not at the top level (most likely because a closing brace was missing at the end of a header file, but is also possible if submodule headers attempt to do something fundamentally non-modular, like our .def files). llvm-svn: 195543
2013-11-23 12:06:09 +08:00
// If all is good, enter the new file!
Track the currently-being-built submodule inside the preprocessor (rather than just storing a flag indicating if there was one), and include it in the 'end of module' annotation. No functionality change. llvm-svn: 200573
2014-02-01 04:47:44 +08:00
if (EnterSourceFile(FID, CurDir, FilenameTok.getLocation()))
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
return {ImportAction::None};
Generate a marker token when entering or leaving a submodule when building a module. Use the marker to diagnose cases where we try to transition between submodules when not at the top level (most likely because a closing brace was missing at the end of a header file, but is also possible if submodule headers attempt to do something fundamentally non-modular, like our .def files). llvm-svn: 195543
2013-11-23 12:06:09 +08:00
[modules] If we see a #include that maps to a module, but use of precompiled modules is disabled, track submodule visibility anyway if -fmodules-local-submodule-visibility is enabled. This, in effect, gives modules semantics but without precompilation. llvm-svn: 237550
2015-05-18 11:52:30 +08:00
// Determine if we're switching to building a new submodule, and which one.
if (auto *M = SuggestedModule.getModule()) {
Reapply r321781: [Modules] Allow modules specified by -fmodule-map-file to shadow implicitly found ones When modules come from module map files explicitly specified by -fmodule-map-file= arguments, allow those to override/shadow modules with the same name that are found implicitly by header search. If such a module is looked up by name (e.g. @import), we will always find the one from -fmodule-map-file. If we try to use a shadowed module by including one of its headers report an error. This enables developers to force use of a specific copy of their module to be used if there are multiple copies that would otherwise be visible, for example if they develop modules that are installed in the default search paths. Patch originally by Ben Langmuir, http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20151116/143425.html Based on cfe-dev discussion: http://lists.llvm.org/pipermail/cfe-dev/2015-November/046164.html Differential Revision: https://reviews.llvm.org/D31269 rdar://problem/23612102 llvm-svn: 321855
2018-01-05 10:33:18 +08:00
if (M->getTopLevelModule()->ShadowingModule) {
// We are building a submodule that belongs to a shadowed module. This
// means we find header files in the shadowed module.
Diag(M->DefinitionLoc, diag::err_module_build_shadowed_submodule)
<< M->getFullModuleName();
Diag(M->getTopLevelModule()->ShadowingModule->DefinitionLoc,
diag::note_previous_definition);
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
return {ImportAction::None};
Reapply r321781: [Modules] Allow modules specified by -fmodule-map-file to shadow implicitly found ones When modules come from module map files explicitly specified by -fmodule-map-file= arguments, allow those to override/shadow modules with the same name that are found implicitly by header search. If such a module is looked up by name (e.g. @import), we will always find the one from -fmodule-map-file. If we try to use a shadowed module by including one of its headers report an error. This enables developers to force use of a specific copy of their module to be used if there are multiple copies that would otherwise be visible, for example if they develop modules that are installed in the default search paths. Patch originally by Ben Langmuir, http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20151116/143425.html Based on cfe-dev discussion: http://lists.llvm.org/pipermail/cfe-dev/2015-November/046164.html Differential Revision: https://reviews.llvm.org/D31269 rdar://problem/23612102 llvm-svn: 321855
2018-01-05 10:33:18 +08:00
}
PCH: fix a regression that reports a module is defined in both pch and pcm. In r276159, we started to say that a module X is defined in a pch if we specify -fmodule-name when building the pch. This caused a regression that reports module X is defined in both pch and pcm if we generate the pch with -fmodule-name=X and then in a separate clang invocation, we include the pch and also import X.pcm. This patch adds an option CompilingPCH similar to CompilingModule. When we use -fmodule-name=X while building a pch, modular headers in X will be textually included and the compiler knows that we are not building module X, so we don't put module X in SUBMODULE_DEFINITION of the pch. Differential Revision: http://reviews.llvm.org/D28415 llvm-svn: 291465
2017-01-10 03:20:18 +08:00
// When building a pch, -fmodule-name tells the compiler to textually
// include headers in the specified module. We are not building the
// specified module.
Refactor handling of #include directives to cleanly separate the "skipped header because it should be imported as a module" cases from the "skipped header because of some other reason" cases. llvm-svn: 356704
2019-03-22 03:44:17 +08:00
//
// FIXME: This is the wrong way to handle this. We should produce a PCH
// that behaves the same as the header would behave in a compilation using
// that PCH, which means we should enter the submodule. We need to teach
// the AST serialization layer to deal with the resulting AST.
PCH: fix a regression that reports a module is defined in both pch and pcm. In r276159, we started to say that a module X is defined in a pch if we specify -fmodule-name when building the pch. This caused a regression that reports module X is defined in both pch and pcm if we generate the pch with -fmodule-name=X and then in a separate clang invocation, we include the pch and also import X.pcm. This patch adds an option CompilingPCH similar to CompilingModule. When we use -fmodule-name=X while building a pch, modular headers in X will be textually included and the compiler knows that we are not building module X, so we don't put module X in SUBMODULE_DEFINITION of the pch. Differential Revision: http://reviews.llvm.org/D28415 llvm-svn: 291465
2017-01-10 03:20:18 +08:00
if (getLangOpts().CompilingPCH &&
[Modules] Honor -fmodule-name when handling private framework modules When skipping building the module for a private framework module, LangOpts.CurrentModule isn't enough for implict modules builds; for instance, in case a private module is built while building a public one, LangOpts.CurrentModule doesn't reflect the -fmodule-name being passed down, but instead the module name which triggered the build. Store the actual -fmodule-name in LangOpts.ModuleName and actually check a name was provided during compiler invocation in order to skip building the private module. rdar://problem/38434694 llvm-svn: 328053
2018-03-21 06:36:39 +08:00
isForModuleBuilding(M, getLangOpts().CurrentModule,
getLangOpts().ModuleName))
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
return {ImportAction::None};
PCH: fix a regression that reports a module is defined in both pch and pcm. In r276159, we started to say that a module X is defined in a pch if we specify -fmodule-name when building the pch. This caused a regression that reports module X is defined in both pch and pcm if we generate the pch with -fmodule-name=X and then in a separate clang invocation, we include the pch and also import X.pcm. This patch adds an option CompilingPCH similar to CompilingModule. When we use -fmodule-name=X while building a pch, modular headers in X will be textually included and the compiler knows that we are not building module X, so we don't put module X in SUBMODULE_DEFINITION of the pch. Differential Revision: http://reviews.llvm.org/D28415 llvm-svn: 291465
2017-01-10 03:20:18 +08:00
Add #pragma clang module begin/end pragmas and generate them when preprocessing a module. These pragmas are intended to simulate the effect of entering or leaving a file with an associated module. This is not completely implemented yet: declarations between the pragmas will not be attributed to the correct module, but macro visibility is already functional. Modules named by #pragma clang module begin must already be known to clang (in some module map that's either loaded or on the search path). llvm-svn: 302098
2017-05-04 08:29:54 +08:00
assert(!CurLexerSubmodule && "should not have marked this as a module yet");
CurLexerSubmodule = M;
Track the currently-being-built submodule inside the preprocessor (rather than just storing a flag indicating if there was one), and include it in the 'end of module' annotation. No functionality change. llvm-svn: 200573
2014-02-01 04:47:44 +08:00
[modules] If we see a #include that maps to a module, but use of precompiled modules is disabled, track submodule visibility anyway if -fmodules-local-submodule-visibility is enabled. This, in effect, gives modules semantics but without precompilation. llvm-svn: 237550
2015-05-18 11:52:30 +08:00
// Let the macro handling code know that any future macros are within
// the new submodule.
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
EnterSubmodule(M, EndLoc, /*ForPragma*/false);
[modules] Determine the set of macros exported by a submodule at the end of that submodule. Previously we'd defer this determination until writing the AST, which doesn't allow us to use this information when building other submodules of the same module. This change also allows us to use a uniform mechanism for writing module macro records, independent of whether they are local or imported. llvm-svn: 235614
2015-04-24 02:18:26 +08:00
[modules] If we see a #include that maps to a module, but use of precompiled modules is disabled, track submodule visibility anyway if -fmodules-local-submodule-visibility is enabled. This, in effect, gives modules semantics but without precompilation. llvm-svn: 237550
2015-05-18 11:52:30 +08:00
// Let the parser know that any future declarations are within the new
// submodule.
// FIXME: There's no point doing this if we're handling a #__include_macros
// directive.
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
return {ImportAction::ModuleBegin, M};
Track the currently-being-built submodule inside the preprocessor (rather than just storing a flag indicating if there was one), and include it in the 'end of module' annotation. No functionality change. llvm-svn: 200573
2014-02-01 04:47:44 +08:00
}
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
return {ImportAction::None};
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
Documentation cleanup: * Add \brief summaries; * Escape # characters in Doxygen comments; * Add \code...\endcode markup for code examples; * Add \verbatim...\endverbatim markup for grammar productions. llvm-svn: 158976
2012-06-22 13:46:07 +08:00
/// HandleIncludeNextDirective - Implements \#include_next.
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
///
Extend the preprocessing record and libclang with support for inclusion directives, keeping track of every #include, #import, etc. in the translation unit. We keep track of the source location and kind of the inclusion, how the file name was spelled, and the underlying file to which the inclusion resolved. llvm-svn: 116952
2010-10-21 06:00:55 +08:00
void Preprocessor::HandleIncludeNextDirective(SourceLocation HashLoc,
Token &IncludeNextTok) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Diag(IncludeNextTok, diag::ext_pp_include_next_directive);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// #include_next is like #include, except that we start searching after
// the current found directory. If we can't do this, issue a
// diagnostic.
const DirectoryLookup *Lookup = CurDirLookup;
[modules] Add support for #include_next. #include_next interacts poorly with modules: it depends on where in the list of include paths the current file was found. Files covered by module maps are not found in include search paths when building the module (and are not found in include search paths when @importing the module either), so this isn't really meaningful. Instead, we fake up the result that #include_next *should* have given: find the first path that would have resulted in the given file being picked, and search from there onwards. llvm-svn: 220177
2014-10-20 08:15:49 +08:00
const FileEntry *LookupFromFile = nullptr;
Do not print include_next/pragma once warnings when input is a header. r276653 suppressed the pragma once warning when generating a PCH file. This patch extends that to any main file for which clang is told (with the -x option) that it's a header file. It will also suppress the warning "#include_next in primary source file". Differential Revision: http://reviews.llvm.org/D25989 llvm-svn: 285295
2016-10-27 22:17:10 +08:00
if (isInPrimaryFile() && LangOpts.IsHeaderFile) {
// If the main file is a header, then it's either for PCH/AST generation,
// or libclang opened it. Either way, handle it as a normal include below
// and do not complain about include_next.
} else if (isInPrimaryFile()) {
[C++11] Use 'nullptr'. Lex edition. llvm-svn: 209083
2014-05-18 07:10:59 +08:00
Lookup = nullptr;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Diag(IncludeNextTok, diag::pp_include_next_in_primary);
Add #pragma clang module begin/end pragmas and generate them when preprocessing a module. These pragmas are intended to simulate the effect of entering or leaving a file with an associated module. This is not completely implemented yet: declarations between the pragmas will not be attributed to the correct module, but macro visibility is already functional. Modules named by #pragma clang module begin must already be known to clang (in some module map that's either loaded or on the search path). llvm-svn: 302098
2017-05-04 08:29:54 +08:00
} else if (CurLexerSubmodule) {
[modules] Add support for #include_next. #include_next interacts poorly with modules: it depends on where in the list of include paths the current file was found. Files covered by module maps are not found in include search paths when building the module (and are not found in include search paths when @importing the module either), so this isn't really meaningful. Instead, we fake up the result that #include_next *should* have given: find the first path that would have resulted in the given file being picked, and search from there onwards. llvm-svn: 220177
2014-10-20 08:15:49 +08:00
// Start looking up in the directory *after* the one in which the current
// file would be found, if any.
assert(CurPPLexer && "#include_next directive in macro?");
LookupFromFile = CurPPLexer->getFileEntry();
Lookup = nullptr;
[C++11] Use 'nullptr'. Lex edition. llvm-svn: 209083
2014-05-18 07:10:59 +08:00
} else if (!Lookup) {
Improve the diagnostic for #include_next occurring in a file not found in the include path. Instead of making the incorrect claim that the included file has an absolute path, describe the actual problem: the including file was found either by absolute path, or relative to such a file, or relative to the primary source file. llvm-svn: 356712
2019-03-22 04:42:13 +08:00
// The current file was not found by walking the include path. Either it
// is the primary file (handled above), or it was found by absolute path,
// or it was found relative to such a file.
// FIXME: Track enough information so we know which case we're in.
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Diag(IncludeNextTok, diag::pp_include_next_absolute_path);
} else {
// Start looking up in the next directory.
++Lookup;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[modules] Add support for #include_next. #include_next interacts poorly with modules: it depends on where in the list of include paths the current file was found. Files covered by module maps are not found in include search paths when building the module (and are not found in include search paths when @importing the module either), so this isn't really meaningful. Instead, we fake up the result that #include_next *should* have given: find the first path that would have resulted in the given file being picked, and search from there onwards. llvm-svn: 220177
2014-10-20 08:15:49 +08:00
return HandleIncludeDirective(HashLoc, IncludeNextTok, Lookup,
LookupFromFile);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
Documentation cleanup: * Add \brief summaries; * Escape # characters in Doxygen comments; * Add \code...\endcode markup for code examples; * Add \verbatim...\endverbatim markup for grammar productions. llvm-svn: 158976
2012-06-22 13:46:07 +08:00
/// HandleMicrosoftImportDirective - Implements \#import for Microsoft Mode
Turns #import in MS Mode into an error. llvm-svn: 153009
2012-03-18 11:10:37 +08:00
void Preprocessor::HandleMicrosoftImportDirective(Token &Tok) {
// The Microsoft #import directive takes a type library and generates header
// files from it, and includes those. This is beyond the scope of what clang
// does, so we ignore it and error out. However, #import can optionally have
// trailing attributes that span multiple lines. We're going to eat those
// so we can continue processing from there.
Diag(Tok, diag::err_pp_import_directive_ms );
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
// Read tokens until we get to the end of the directive. Note that the
Turns #import in MS Mode into an error. llvm-svn: 153009
2012-03-18 11:10:37 +08:00
// directive can be split over multiple lines using the backslash character.
DiscardUntilEndOfDirective();
}
Documentation cleanup: * Add \brief summaries; * Escape # characters in Doxygen comments; * Add \code...\endcode markup for code examples; * Add \verbatim...\endverbatim markup for grammar productions. llvm-svn: 158976
2012-06-22 13:46:07 +08:00
/// HandleImportDirective - Implements \#import.
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
///
Extend the preprocessing record and libclang with support for inclusion directives, keeping track of every #include, #import, etc. in the translation unit. We keep track of the source location and kind of the inclusion, how the file name was spelled, and the underlying file to which the inclusion resolved. llvm-svn: 116952
2010-10-21 06:00:55 +08:00
void Preprocessor::HandleImportDirective(SourceLocation HashLoc,
Token &ImportTok) {
NFC: Remove the ObjC1/ObjC2 distinction from clang (and related projects) We haven't supported compiling ObjC1 for a long time (and never will again), so there isn't any reason to keep these separate. This patch replaces LangOpts::ObjC1 and LangOpts::ObjC2 with LangOpts::ObjC. Differential revision: https://reviews.llvm.org/D53547 llvm-svn: 345637
2018-10-31 04:31:30 +08:00
if (!LangOpts.ObjC) { // #import is standard for ObjC.
Rename language option MicrosoftMode to MSVCCompat There's been long-standing confusion over the role of these two options. This commit makes the necessary changes to differentiate them clearly, following up from r198936. MicrosoftExt (aka. fms-extensions): Enable largely unobjectionable Microsoft language extensions to ease portability. This mode, also supported by gcc, is used for building software like FreeBSD and Linux kernel extensions that share code with Windows drivers. MSVCCompat (aka. -fms-compatibility, formerly MicrosoftMode): Turn on a special mode supporting 'heinous' extensions for drop-in compatibility with the Microsoft Visual C++ product. Standards-compilant C and C++ code isn't guaranteed to work in this mode. Implies MicrosoftExt. Note that full -fms-compatibility mode is currently enabled by default on the Windows target, which may need tuning to serve as a reasonable default. See cfe-commits for the full discourse, thread 'r198497 - Move MS predefined type_info out of InitializePredefinedMacros' No change in behaviour. llvm-svn: 199209
2014-01-14 20:51:41 +08:00
if (LangOpts.MSVCCompat)
Turns #import in MS Mode into an error. llvm-svn: 153009
2012-03-18 11:10:37 +08:00
return HandleMicrosoftImportDirective(ImportTok);
#import is not considered an extension for ObjC. llvm-svn: 66246
2009-03-06 12:28:03 +08:00
Diag(ImportTok, diag::ext_pp_import_directive);
Turns #import in MS Mode into an error. llvm-svn: 153009
2012-03-18 11:10:37 +08:00
}
[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor. llvm-svn: 358231
2019-04-12 05:18:23 +08:00
return HandleIncludeDirective(HashLoc, ImportTok);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
reject the #__include_macros directive unless it comes from the predefines buffer. llvm-svn: 68627
2009-04-09 02:46:40 +08:00
/// HandleIncludeMacrosDirective - The -imacros command line option turns into a
/// pseudo directive in the predefines buffer. This handles it by sucking all
/// tokens through the preprocessor and discarding them (only keeping the side
/// effects on the preprocessor).
Extend the preprocessing record and libclang with support for inclusion directives, keeping track of every #include, #import, etc. in the translation unit. We keep track of the source location and kind of the inclusion, how the file name was spelled, and the underlying file to which the inclusion resolved. llvm-svn: 116952
2010-10-21 06:00:55 +08:00
void Preprocessor::HandleIncludeMacrosDirective(SourceLocation HashLoc,
Token &IncludeMacrosTok) {
reject the #__include_macros directive unless it comes from the predefines buffer. llvm-svn: 68627
2009-04-09 02:46:40 +08:00
// This directive should only occur in the predefines buffer. If not, emit an
// error and reject it.
SourceLocation Loc = IncludeMacrosTok.getLocation();
Use StringRef for MemoryBuffer identifier API (NFC) llvm-svn: 283043
2016-10-02 00:38:28 +08:00
if (SourceMgr.getBufferName(Loc) != "<built-in>") {
reject the #__include_macros directive unless it comes from the predefines buffer. llvm-svn: 68627
2009-04-09 02:46:40 +08:00
Diag(IncludeMacrosTok.getLocation(),
diag::pp_include_macros_out_of_predefines);
DiscardUntilEndOfDirective();
return;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
finish the implementation of -imacros. The driver still needs to be hooked up. llvm-svn: 68640
2009-04-09 04:53:24 +08:00
// Treat this as a normal #include for checking purposes. If this is
// successful, it will push a new lexer onto the include stack.
[modules] Add support for #include_next. #include_next interacts poorly with modules: it depends on where in the list of include paths the current file was found. Files covered by module maps are not found in include search paths when building the module (and are not found in include search paths when @importing the module either), so this isn't really meaningful. Instead, we fake up the result that #include_next *should* have given: find the first path that would have resulted in the given file being picked, and search from there onwards. llvm-svn: 220177
2014-10-20 08:15:49 +08:00
HandleIncludeDirective(HashLoc, IncludeMacrosTok);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
finish the implementation of -imacros. The driver still needs to be hooked up. llvm-svn: 68640
2009-04-09 04:53:24 +08:00
Token TmpTok;
do {
Lex(TmpTok);
assert(TmpTok.isNot(tok::eof) && "Didn't find end of -imacros!");
} while (TmpTok.isNot(tok::hashhash));
reject the #__include_macros directive unless it comes from the predefines buffer. llvm-svn: 68627
2009-04-09 02:46:40 +08:00
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
//===----------------------------------------------------------------------===//
// Preprocessor Macro Directive Handling.
//===----------------------------------------------------------------------===//
[NFC] Replace 'arguments' with 'parameters' in comments relating to lexing a macro definition. llvm-svn: 314484
2017-09-29 10:43:22 +08:00
/// ReadMacroParameterList - The ( starting a parameter list of a macro
/// definition has just been read. Lex the rest of the parameters and the
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
/// closing ), updating MI with what we learn. Return true if an error occurs
[NFC] Replace 'arguments' with 'parameters' in comments relating to lexing a macro definition. llvm-svn: 314484
2017-09-29 10:43:22 +08:00
/// parsing the param list.
[NFC] Refactor the Preprocessor function that handles Macro definitions and rename Arguments to Parameters in Macro Definitions. - Extracted the reading of the tokens out into a separate function. - Replace 'Argument' with 'Parameter' when referring to the identifiers of the macro definition (as opposed to the supplied arguments - MacroArgs - during the macro invocation). This is in preparation for submitting patches for review to implement __VA_OPT__ which will otherwise just keep lengthening the HandleDefineDirective function and making it less comprehensible. I will also directly update some extra clang tooling that is broken by the change from Argument to Parameter. Hopefully the bots will stay appeased. Thanks! llvm-svn: 308190
2017-07-18 01:18:43 +08:00
bool Preprocessor::ReadMacroParameterList(MacroInfo *MI, Token &Tok) {
[NFC] Rename variable 'Arguments' to 'Parameters' when lexing the Macro Definition. llvm-svn: 314483
2017-09-29 10:17:31 +08:00
SmallVector<IdentifierInfo*, 32> Parameters;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes. Differential revision: https://reviews.llvm.org/D24115 llvm-svn: 280870
2016-09-08 05:53:17 +08:00
while (true) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
LexUnexpandedToken(Tok);
switch (Tok.getKind()) {
case tok::r_paren:
[NFC] Replace 'arguments' with 'parameters' in comments relating to lexing a macro definition. llvm-svn: 314484
2017-09-29 10:43:22 +08:00
// Found the end of the parameter list.
[NFC] Rename variable 'Arguments' to 'Parameters' when lexing the Macro Definition. llvm-svn: 314483
2017-09-29 10:17:31 +08:00
if (Parameters.empty()) // #define FOO()
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
return false;
// Otherwise we have #define FOO(A,)
Diag(Tok, diag::err_pp_expected_ident_in_arg_list);
return true;
case tok::ellipsis: // #define X(... -> C99 varargs
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (!LangOpts.C99)
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
Diag(Tok, LangOpts.CPlusPlus11 ?
-Wc++98-compat warnings for the lexer. This also adds a -Wc++98-compat-pedantic for warning on constructs which would be diagnosed by -std=c++98 -pedantic (that is, it warns even on C++11 features which we enable by default, with no warning, in C++98 mode). llvm-svn: 142034
2011-10-15 09:18:56 +08:00
diag::warn_cxx98_compat_variadic_macro :
diag::ext_variadic_macro);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Add some semantic checks for OpenCL. Variadic macros, VLAs and bitfields are not supported. llvm-svn: 172732
2013-01-18 01:35:00 +08:00
// OpenCL v1.2 s6.9.e: variadic macros are not supported.
if (LangOpts.OpenCL) {
[OpenCL] Allow variadic macros as Clang feature. llvm-svn: 356987
2019-03-26 19:22:37 +08:00
Diag(Tok, diag::ext_pp_opencl_variadic_macros);
Add some semantic checks for OpenCL. Variadic macros, VLAs and bitfields are not supported. llvm-svn: 172732
2013-01-18 01:35:00 +08:00
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Lex the token after the identifier.
LexUnexpandedToken(Tok);
if (Tok.isNot(tok::r_paren)) {
Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
return true;
}
[NFC] Replace 'arguments' with 'parameters' in comments relating to lexing a macro definition. llvm-svn: 314484
2017-09-29 10:43:22 +08:00
// Add the __VA_ARGS__ identifier as a parameter.
[NFC] Rename variable 'Arguments' to 'Parameters' when lexing the Macro Definition. llvm-svn: 314483
2017-09-29 10:17:31 +08:00
Parameters.push_back(Ident__VA_ARGS__);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
MI->setIsC99Varargs();
[NFC] Rename variable 'Arguments' to 'Parameters' when lexing the Macro Definition. llvm-svn: 314483
2017-09-29 10:17:31 +08:00
MI->setParameterList(Parameters, BP);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
return false;
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
case tok::eod: // #define X(
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
return true;
default:
// Handle keywords and identifiers here to accept things like
// #define Foo(for) for.
IdentifierInfo *II = Tok.getIdentifierInfo();
[C++11] Use 'nullptr'. Lex edition. llvm-svn: 209083
2014-05-18 07:10:59 +08:00
if (!II) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// #define X(1
Diag(Tok, diag::err_pp_invalid_tok_in_arg_list);
return true;
}
[NFC] Replace 'arguments' with 'parameters' in comments relating to lexing a macro definition. llvm-svn: 314484
2017-09-29 10:43:22 +08:00
// If this is already used as a parameter, it is used multiple times (e.g.
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// #define X(A,A.
Range-style std::find{,_if} -> llvm::find{,_if}. NFC llvm-svn: 357359
2019-03-31 16:48:19 +08:00
if (llvm::find(Parameters, II) != Parameters.end()) { // C99 6.10.3p6
don't turn identifierinfo's into strings in diagnostics. llvm-svn: 59602
2008-11-19 15:33:58 +08:00
Diag(Tok, diag::err_pp_duplicate_name_in_arg_list) << II;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
return true;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[NFC] Replace 'arguments' with 'parameters' in comments relating to lexing a macro definition. llvm-svn: 314484
2017-09-29 10:43:22 +08:00
// Add the parameter to the macro info.
[NFC] Rename variable 'Arguments' to 'Parameters' when lexing the Macro Definition. llvm-svn: 314483
2017-09-29 10:17:31 +08:00
Parameters.push_back(II);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Lex the token after the identifier.
LexUnexpandedToken(Tok);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
switch (Tok.getKind()) {
default: // #define X(A B
Diag(Tok, diag::err_pp_expected_comma_in_arg_list);
return true;
case tok::r_paren: // #define X(A)
[NFC] Rename variable 'Arguments' to 'Parameters' when lexing the Macro Definition. llvm-svn: 314483
2017-09-29 10:17:31 +08:00
MI->setParameterList(Parameters, BP);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
return false;
case tok::comma: // #define X(A,
break;
case tok::ellipsis: // #define X(A... -> GCC extension
// Diagnose extension.
Diag(Tok, diag::ext_named_variadic_macro);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Lex the token after the identifier.
LexUnexpandedToken(Tok);
if (Tok.isNot(tok::r_paren)) {
Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
return true;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
MI->setIsGNUVarargs();
[NFC] Rename variable 'Arguments' to 'Parameters' when lexing the Macro Definition. llvm-svn: 314483
2017-09-29 10:17:31 +08:00
MI->setParameterList(Parameters, BP);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
return false;
}
}
}
}
Fixed warnings on redefine keywords and reserved ids. Repared support for warnings -Wkeyword-macro and -Wreserved-id-macro. The warning -Wkeyword-macro now is not issued in patterns that are used in configuration scripts: #define inline also for 'const', 'extern' and 'static'. If macro repalcement is identical to macro name, the warning also is not issued: #define volatile volatile And finally if macro replacement is also a keyword identical to the replaced one but decorated with leading/trailing underscores: #define inline __inline #define inline __inline__ #define inline _inline // in MSVC compatibility mode Warning -Wreserved-id-macro is off by default, it could help catching things like: #undef __cplusplus llvm-svn: 224512
2014-12-18 19:14:21 +08:00
static bool isConfigurationPattern(Token &MacroName, MacroInfo *MI,
const LangOptions &LOptions) {
if (MI->getNumTokens() == 1) {
const Token &Value = MI->getReplacementToken(0);
// Macro that is identity, like '#define inline inline' is a valid pattern.
if (MacroName.getKind() == Value.getKind())
return true;
// Macro that maps a keyword to the same keyword decorated with leading/
// trailing underscores is a valid pattern:
// #define inline __inline
// #define inline __inline__
// #define inline _inline (in MS compatibility mode)
StringRef MacroText = MacroName.getIdentifierInfo()->getName();
if (IdentifierInfo *II = Value.getIdentifierInfo()) {
if (!II->isKeyword(LOptions))
return false;
StringRef ValueText = II->getName();
StringRef TrimmedValue = ValueText;
if (!ValueText.startswith("__")) {
if (ValueText.startswith("_"))
TrimmedValue = TrimmedValue.drop_front(1);
else
return false;
} else {
TrimmedValue = TrimmedValue.drop_front(2);
if (TrimmedValue.endswith("__"))
TrimmedValue = TrimmedValue.drop_back(2);
}
return TrimmedValue.equals(MacroText);
} else {
return false;
}
}
// #define inline
Refactor: Simplify boolean conditional return statements in lib/Lex Summary: Use clang-tidy to simplify boolean conditional return statements Reviewers: dblaikie Subscribers: dblaikie, cfe-commits Patch by Richard Thomson! Differential Revision: http://reviews.llvm.org/D10017 llvm-svn: 256499
2015-12-28 23:30:42 +08:00
return MacroName.isOneOf(tok::kw_extern, tok::kw_inline, tok::kw_static,
tok::kw_const) &&
MI->getNumTokens() == 0;
Fixed warnings on redefine keywords and reserved ids. Repared support for warnings -Wkeyword-macro and -Wreserved-id-macro. The warning -Wkeyword-macro now is not issued in patterns that are used in configuration scripts: #define inline also for 'const', 'extern' and 'static'. If macro repalcement is identical to macro name, the warning also is not issued: #define volatile volatile And finally if macro replacement is also a keyword identical to the replaced one but decorated with leading/trailing underscores: #define inline __inline #define inline __inline__ #define inline _inline // in MSVC compatibility mode Warning -Wreserved-id-macro is off by default, it could help catching things like: #undef __cplusplus llvm-svn: 224512
2014-12-18 19:14:21 +08:00
}
[NFC] Refactor the Preprocessor function that handles Macro definitions and rename Arguments to Parameters in Macro Definitions. - Extracted the reading of the tokens out into a separate function. - Replace 'Argument' with 'Parameter' when referring to the identifiers of the macro definition (as opposed to the supplied arguments - MacroArgs - during the macro invocation). This is in preparation for submitting patches for review to implement __VA_OPT__ which will otherwise just keep lengthening the HandleDefineDirective function and making it less comprehensible. I will also directly update some extra clang tooling that is broken by the change from Argument to Parameter. Hopefully the bots will stay appeased. Thanks! llvm-svn: 308190
2017-07-18 01:18:43 +08:00
// ReadOptionalMacroParameterListAndBody - This consumes all (i.e. the
// entire line) of the macro's tokens and adds them to MacroInfo, and while
// doing so performs certain validity checks including (but not limited to):
// - # (stringization) is followed by a macro parameter
//
// Returns a nullptr if an invalid sequence of tokens is encountered or returns
// a pointer to a MacroInfo object.
Revert changes from my previous refactoring - will need to fix dependencies in clang's extra tooling (such as clang-tidy etc.). Sorry about that. llvm-svn: 308158
2017-07-17 10:03:21 +08:00
[NFC] Refactor the Preprocessor function that handles Macro definitions and rename Arguments to Parameters in Macro Definitions. - Extracted the reading of the tokens out into a separate function. - Replace 'Argument' with 'Parameter' when referring to the identifiers of the macro definition (as opposed to the supplied arguments - MacroArgs - during the macro invocation). This is in preparation for submitting patches for review to implement __VA_OPT__ which will otherwise just keep lengthening the HandleDefineDirective function and making it less comprehensible. I will also directly update some extra clang tooling that is broken by the change from Argument to Parameter. Hopefully the bots will stay appeased. Thanks! llvm-svn: 308190
2017-07-18 01:18:43 +08:00
MacroInfo *Preprocessor::ReadOptionalMacroParameterListAndBody(
const Token &MacroNameTok, const bool ImmediatelyAfterHeaderGuard) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
improve MacroInfo to track the source range of the macro definition, patch by Alexei Svitkine! llvm-svn: 69659
2009-04-21 12:46:33 +08:00
Token LastTok = MacroNameTok;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Create the new macro.
[NFC] Refactor the Preprocessor function that handles Macro definitions and rename Arguments to Parameters in Macro Definitions. - Extracted the reading of the tokens out into a separate function. - Replace 'Argument' with 'Parameter' when referring to the identifiers of the macro definition (as opposed to the supplied arguments - MacroArgs - during the macro invocation). This is in preparation for submitting patches for review to implement __VA_OPT__ which will otherwise just keep lengthening the HandleDefineDirective function and making it less comprehensible. I will also directly update some extra clang tooling that is broken by the change from Argument to Parameter. Hopefully the bots will stay appeased. Thanks! llvm-svn: 308190
2017-07-18 01:18:43 +08:00
MacroInfo *const MI = AllocateMacroInfo(MacroNameTok.getLocation());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Token Tok;
LexUnexpandedToken(Tok);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[NFC] Use RAII to un-poison and then re-poison __VA_ARGS__ - This will also be used for the forthcoming __VA_OPT__ feature approved for C++2a. - recommended by rsmith during his review of the __VA_OPT__ patch (https://reviews.llvm.org/D35782) llvm-svn: 308948
2017-07-25 11:15:36 +08:00
// Used to un-poison and then re-poison identifiers of the __VA_ARGS__ ilk
// within their appropriate context.
VariadicMacroScopeGuard VariadicMacroScopeGuard(*this);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// If this is a function-like macro definition, parse the argument list,
// marking each of the identifiers as being used as macro arguments. Also,
// check other constraints on the first token of the macro body.
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
if (Tok.is(tok::eod)) {
Introducing -Wheader-guard, a warning that checks header guards actually work properly. This warning checks that the #ifndef and #define directives at the beginning of a header refer to the same macro name. Includes a fix-it hint to correct the header guard. llvm-svn: 183867
2013-06-13 05:20:57 +08:00
if (ImmediatelyAfterHeaderGuard) {
// Save this macro information since it may part of a header guard.
CurPPLexer->MIOpt.SetDefinedMacro(MacroNameTok.getIdentifierInfo(),
MacroNameTok.getLocation());
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// If there is no body to this macro, we have no special handling here.
enforce requirements imposed by C90 6.8 TC1, fixing PR3919. llvm-svn: 69415
2009-04-18 10:23:25 +08:00
} else if (Tok.hasLeadingSpace()) {
// This is a normal token with leading space. Clear the leading space
// marker on the first token to get proper expansion.
Tok.clearFlag(Token::LeadingSpace);
} else if (Tok.is(tok::l_paren)) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// This is a function-like macro definition. Read the argument list.
MI->setIsFunctionLike();
[NFC] Refactor the Preprocessor function that handles Macro definitions and rename Arguments to Parameters in Macro Definitions. - Extracted the reading of the tokens out into a separate function. - Replace 'Argument' with 'Parameter' when referring to the identifiers of the macro definition (as opposed to the supplied arguments - MacroArgs - during the macro invocation). This is in preparation for submitting patches for review to implement __VA_OPT__ which will otherwise just keep lengthening the HandleDefineDirective function and making it less comprehensible. I will also directly update some extra clang tooling that is broken by the change from Argument to Parameter. Hopefully the bots will stay appeased. Thanks! llvm-svn: 308190
2017-07-18 01:18:43 +08:00
if (ReadMacroParameterList(MI, LastTok)) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Throw away the rest of the line.
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
if (CurPPLexer->ParsingPreprocessorDirective)
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
DiscardUntilEndOfDirective();
[NFC] Refactor the Preprocessor function that handles Macro definitions and rename Arguments to Parameters in Macro Definitions. - Extracted the reading of the tokens out into a separate function. - Replace 'Argument' with 'Parameter' when referring to the identifiers of the macro definition (as opposed to the supplied arguments - MacroArgs - during the macro invocation). This is in preparation for submitting patches for review to implement __VA_OPT__ which will otherwise just keep lengthening the HandleDefineDirective function and making it less comprehensible. I will also directly update some extra clang tooling that is broken by the change from Argument to Parameter. Hopefully the bots will stay appeased. Thanks! llvm-svn: 308190
2017-07-18 01:18:43 +08:00
return nullptr;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
[NFC] Use RAII to un-poison and then re-poison __VA_ARGS__ - This will also be used for the forthcoming __VA_OPT__ feature approved for C++2a. - recommended by rsmith during his review of the __VA_OPT__ patch (https://reviews.llvm.org/D35782) llvm-svn: 308948
2017-07-25 11:15:36 +08:00
// If this is a definition of an ISO C/C++ variadic function-like macro (not
// using the GNU named varargs extension) inform our variadic scope guard
// which un-poisons and re-poisons certain identifiers (e.g. __VA_ARGS__)
// allowed only within the definition of a variadic macro.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[NFC] Use RAII to un-poison and then re-poison __VA_ARGS__ - This will also be used for the forthcoming __VA_OPT__ feature approved for C++2a. - recommended by rsmith during his review of the __VA_OPT__ patch (https://reviews.llvm.org/D35782) llvm-svn: 308948
2017-07-25 11:15:36 +08:00
if (MI->isC99Varargs()) {
VariadicMacroScopeGuard.enterScope();
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Read the first token after the arg list for down below.
LexUnexpandedToken(Tok);
s/CPlusPlus0x/CPlusPlus11/g llvm-svn: 171367
2013-01-02 19:42:31 +08:00
} else if (LangOpts.C99 || LangOpts.CPlusPlus11) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// C99 requires whitespace between the macro definition and the body. Emit
// a diagnostic for something like "#define X+".
enforce requirements imposed by C90 6.8 TC1, fixing PR3919. llvm-svn: 69415
2009-04-18 10:23:25 +08:00
Diag(Tok, diag::ext_c99_whitespace_required_after_macro_name);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
} else {
enforce requirements imposed by C90 6.8 TC1, fixing PR3919. llvm-svn: 69415
2009-04-18 10:23:25 +08:00
// C90 6.8 TC1 says: "In the definition of an object-like macro, if the
// first character of a replacement list is not a character required by
// subclause 5.2.1, then there shall be white-space separation between the
// identifier and the replacement list.". 5.2.1 lists this set:
// "A-Za-z0-9!"#%&'()*+,_./:;<=>?[\]^_{|}~" as well as whitespace, which
// is irrelevant here.
bool isInvalid = false;
if (Tok.is(tok::at)) // @ is not in the list above.
isInvalid = true;
else if (Tok.is(tok::unknown)) {
// If we have an unknown token, it is something strange like "`". Since
// all of valid characters would have lexed into a single character
// token of some sort, we know this is not a valid case.
isInvalid = true;
}
if (isInvalid)
Diag(Tok, diag::ext_missing_whitespace_after_macro_name);
else
Diag(Tok, diag::warn_missing_whitespace_after_macro_name);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
improve MacroInfo to track the source range of the macro definition, patch by Alexei Svitkine! llvm-svn: 69659
2009-04-21 12:46:33 +08:00
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
if (!Tok.is(tok::eod))
improve MacroInfo to track the source range of the macro definition, patch by Alexei Svitkine! llvm-svn: 69659
2009-04-21 12:46:33 +08:00
LastTok = Tok;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Read the rest of the macro body.
if (MI->isObjectLike()) {
// Object-like macros are very simple, just read their body.
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
while (Tok.isNot(tok::eod)) {
improve MacroInfo to track the source range of the macro definition, patch by Alexei Svitkine! llvm-svn: 69659
2009-04-21 12:46:33 +08:00
LastTok = Tok;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
MI->AddTokenToBody(Tok);
// Get the next token of the macro.
LexUnexpandedToken(Tok);
}
} else {
Fix a couple of bugs: 1. When we accept "#garbage" in asm-with-cpp mode, change the token kind of the # to unknown so that the preprocessor won't try to process it as a real #. This fixes a crash on the attached example 2. Fix macro definition extents processing to handle #foo at the end of a macro to say the definition ends with the foo, not the #. This is a follow-on fix to r72283, and rdar://6916026 llvm-svn: 72388
2009-05-26 01:16:10 +08:00
// Otherwise, read the body of a function-like macro. While we are at it,
// check C99 6.10.3.2p1: ensure that # operators are followed by macro
// parameters in function-like macro expansions.
[c++2a] Implement P0306 __VA_OPT__ (Comma omission and comma deletion) This patch implements an extension to the preprocessor: __VA_OPT__(contents) --> which expands into its contents if variadic arguments are supplied to the parent macro, or behaves as an empty token if none. - Currently this feature is only enabled for C++2a (this could be enabled, with some careful tweaks, for other dialects with the appropriate extension or compatibility warnings) - The patch was reviewed here: https://reviews.llvm.org/D35782 and asides from the above (and moving some of the definition and expansion recognition logic into the corresponding state machines), I believe I incorporated all of Richard's suggestions. A few technicalities (most of which were clarified through private correspondence between rsmith, hubert and thomas) are worth mentioning. Given: #define F(a,...) a #__VA_OPT__(a ## a) a ## __VA_OPT__(__VA_ARGS__) - The call F(,) Does not supply any tokens for the variadic arguments and hence VA_OPT behaves as a placeholder. - When expanding VA_OPT (for e.g. F(,1) token pasting occurs eagerly within its contents if the contents need to be stringified. - A hash or a hashhash prior to VA_OPT does not inhibit expansion of arguments if they are the first token within VA_OPT. - When a variadic argument is supplied, argument substitution occurs within the contents as does stringification - and these resulting tokens are inserted back into the macro expansions token stream just prior to the entire stream being rescanned and concatenated. See wg21.link/P0306 for further details on the feature. Acknowledgment: This patch would have been poorer if not for Richard Smith's usual thoughtful analysis and feedback. llvm-svn: 315840
2017-10-15 09:26:26 +08:00
VAOptDefinitionContext VAOCtx(*this);
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
while (Tok.isNot(tok::eod)) {
improve MacroInfo to track the source range of the macro definition, patch by Alexei Svitkine! llvm-svn: 69659
2009-04-21 12:46:33 +08:00
LastTok = Tok;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Diagnose missing macro argument following charize operator. For completeness, add a test-case for the equivalent stringize operator diagnostic too. llvm-svn: 265177
2016-04-02 03:02:20 +08:00
if (!Tok.isOneOf(tok::hash, tok::hashat, tok::hashhash)) {
Fix a couple of bugs: 1. When we accept "#garbage" in asm-with-cpp mode, change the token kind of the # to unknown so that the preprocessor won't try to process it as a real #. This fixes a crash on the attached example 2. Fix macro definition extents processing to handle #foo at the end of a macro to say the definition ends with the foo, not the #. This is a follow-on fix to r72283, and rdar://6916026 llvm-svn: 72388
2009-05-26 01:16:10 +08:00
MI->AddTokenToBody(Tok);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[c++2a] Implement P0306 __VA_OPT__ (Comma omission and comma deletion) This patch implements an extension to the preprocessor: __VA_OPT__(contents) --> which expands into its contents if variadic arguments are supplied to the parent macro, or behaves as an empty token if none. - Currently this feature is only enabled for C++2a (this could be enabled, with some careful tweaks, for other dialects with the appropriate extension or compatibility warnings) - The patch was reviewed here: https://reviews.llvm.org/D35782 and asides from the above (and moving some of the definition and expansion recognition logic into the corresponding state machines), I believe I incorporated all of Richard's suggestions. A few technicalities (most of which were clarified through private correspondence between rsmith, hubert and thomas) are worth mentioning. Given: #define F(a,...) a #__VA_OPT__(a ## a) a ## __VA_OPT__(__VA_ARGS__) - The call F(,) Does not supply any tokens for the variadic arguments and hence VA_OPT behaves as a placeholder. - When expanding VA_OPT (for e.g. F(,1) token pasting occurs eagerly within its contents if the contents need to be stringified. - A hash or a hashhash prior to VA_OPT does not inhibit expansion of arguments if they are the first token within VA_OPT. - When a variadic argument is supplied, argument substitution occurs within the contents as does stringification - and these resulting tokens are inserted back into the macro expansions token stream just prior to the entire stream being rescanned and concatenated. See wg21.link/P0306 for further details on the feature. Acknowledgment: This patch would have been poorer if not for Richard Smith's usual thoughtful analysis and feedback. llvm-svn: 315840
2017-10-15 09:26:26 +08:00
if (VAOCtx.isVAOptToken(Tok)) {
// If we're already within a VAOPT, emit an error.
if (VAOCtx.isInVAOpt()) {
Diag(Tok, diag::err_pp_vaopt_nested_use);
return nullptr;
}
// Ensure VAOPT is followed by a '(' .
LexUnexpandedToken(Tok);
if (Tok.isNot(tok::l_paren)) {
Diag(Tok, diag::err_pp_missing_lparen_in_vaopt_use);
return nullptr;
}
MI->AddTokenToBody(Tok);
VAOCtx.sawVAOptFollowedByOpeningParens(Tok.getLocation());
LexUnexpandedToken(Tok);
if (Tok.is(tok::hashhash)) {
Diag(Tok, diag::err_vaopt_paste_at_start);
return nullptr;
}
continue;
} else if (VAOCtx.isInVAOpt()) {
if (Tok.is(tok::r_paren)) {
if (VAOCtx.sawClosingParen()) {
const unsigned NumTokens = MI->getNumTokens();
assert(NumTokens >= 3 && "Must have seen at least __VA_OPT__( "
"and a subsequent tok::r_paren");
if (MI->getReplacementToken(NumTokens - 2).is(tok::hashhash)) {
Diag(Tok, diag::err_vaopt_paste_at_end);
return nullptr;
}
}
} else if (Tok.is(tok::l_paren)) {
VAOCtx.sawOpeningParen(Tok.getLocation());
}
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Get the next token of the macro.
LexUnexpandedToken(Tok);
continue;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Don't give # and ## special treatment when in -traditional-cpp mode. Patch by Austin Seipp! llvm-svn: 185896
2013-07-09 09:00:29 +08:00
// If we're in -traditional mode, then we should ignore stringification
// and token pasting. Mark the tokens as unknown so as not to confuse
// things.
if (getLangOpts().TraditionalCPP) {
Tok.setKind(tok::unknown);
MI->AddTokenToBody(Tok);
// Get the next token of the macro.
LexUnexpandedToken(Tok);
continue;
}
Suppress elided variadic macro argument extension diagnostic for macros using the related comma pasting extension. In certain cases, we used to get two diagnostics for what is essentially one extension. This change suppresses the first diagnostic in certain cases where we know we're going to print the second diagnostic. The diagnostic is redundant, and it can't be suppressed in the definition of the macro because it points at the use of the macro, so we want to avoid printing it if possible. The implementation works by detecting constructs which look like comma pasting at the time of the definition of the macro; this information is then used when the macro is used. (We can't actually detect whether we're using the comma pasting extension until the macro is actually used, but we can detecting constructs which will be comma pasting if the varargs argument is elided.) <rdar://problem/12292192> llvm-svn: 167907
2012-11-14 10:18:46 +08:00
if (Tok.is(tok::hashhash)) {
// If we see token pasting, check if it looks like the gcc comma
// pasting extension. We'll use this information to suppress
// diagnostics later on.
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
Suppress elided variadic macro argument extension diagnostic for macros using the related comma pasting extension. In certain cases, we used to get two diagnostics for what is essentially one extension. This change suppresses the first diagnostic in certain cases where we know we're going to print the second diagnostic. The diagnostic is redundant, and it can't be suppressed in the definition of the macro because it points at the use of the macro, so we want to avoid printing it if possible. The implementation works by detecting constructs which look like comma pasting at the time of the definition of the macro; this information is then used when the macro is used. (We can't actually detect whether we're using the comma pasting extension until the macro is actually used, but we can detecting constructs which will be comma pasting if the varargs argument is elided.) <rdar://problem/12292192> llvm-svn: 167907
2012-11-14 10:18:46 +08:00
// Get the next token of the macro.
LexUnexpandedToken(Tok);
if (Tok.is(tok::eod)) {
MI->AddTokenToBody(LastTok);
break;
}
unsigned NumTokens = MI->getNumTokens();
if (NumTokens && Tok.getIdentifierInfo() == Ident__VA_ARGS__ &&
MI->getReplacementToken(NumTokens-1).is(tok::comma))
MI->setHasCommaPasting();
Lex: Require that '#' be followed by a macro parameter name when preceded by '##' After lexing a '##', we would look ahead and check to see if it was followed by '__VA_ARGS__'. After doing so, we would then go ahead and lex the token. However we would fail in the case where the '##' was followed by a '#' followed by an identifier because we would have lexed the '#' separately from the identifier, bypassing our parameter validation logic. Instead, lex the tokens coming after the '##' later. This fixes PR17804. llvm-svn: 194059
2013-11-05 17:30:17 +08:00
// Things look ok, add the '##' token to the macro.
Suppress elided variadic macro argument extension diagnostic for macros using the related comma pasting extension. In certain cases, we used to get two diagnostics for what is essentially one extension. This change suppresses the first diagnostic in certain cases where we know we're going to print the second diagnostic. The diagnostic is redundant, and it can't be suppressed in the definition of the macro because it points at the use of the macro, so we want to avoid printing it if possible. The implementation works by detecting constructs which look like comma pasting at the time of the definition of the macro; this information is then used when the macro is used. (We can't actually detect whether we're using the comma pasting extension until the macro is actually used, but we can detecting constructs which will be comma pasting if the varargs argument is elided.) <rdar://problem/12292192> llvm-svn: 167907
2012-11-14 10:18:46 +08:00
MI->AddTokenToBody(LastTok);
continue;
}
[c++2a] Implement P0306 __VA_OPT__ (Comma omission and comma deletion) This patch implements an extension to the preprocessor: __VA_OPT__(contents) --> which expands into its contents if variadic arguments are supplied to the parent macro, or behaves as an empty token if none. - Currently this feature is only enabled for C++2a (this could be enabled, with some careful tweaks, for other dialects with the appropriate extension or compatibility warnings) - The patch was reviewed here: https://reviews.llvm.org/D35782 and asides from the above (and moving some of the definition and expansion recognition logic into the corresponding state machines), I believe I incorporated all of Richard's suggestions. A few technicalities (most of which were clarified through private correspondence between rsmith, hubert and thomas) are worth mentioning. Given: #define F(a,...) a #__VA_OPT__(a ## a) a ## __VA_OPT__(__VA_ARGS__) - The call F(,) Does not supply any tokens for the variadic arguments and hence VA_OPT behaves as a placeholder. - When expanding VA_OPT (for e.g. F(,1) token pasting occurs eagerly within its contents if the contents need to be stringified. - A hash or a hashhash prior to VA_OPT does not inhibit expansion of arguments if they are the first token within VA_OPT. - When a variadic argument is supplied, argument substitution occurs within the contents as does stringification - and these resulting tokens are inserted back into the macro expansions token stream just prior to the entire stream being rescanned and concatenated. See wg21.link/P0306 for further details on the feature. Acknowledgment: This patch would have been poorer if not for Richard Smith's usual thoughtful analysis and feedback. llvm-svn: 315840
2017-10-15 09:26:26 +08:00
// Our Token is a stringization operator.
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Get the next token of the macro.
LexUnexpandedToken(Tok);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[c++2a] Implement P0306 __VA_OPT__ (Comma omission and comma deletion) This patch implements an extension to the preprocessor: __VA_OPT__(contents) --> which expands into its contents if variadic arguments are supplied to the parent macro, or behaves as an empty token if none. - Currently this feature is only enabled for C++2a (this could be enabled, with some careful tweaks, for other dialects with the appropriate extension or compatibility warnings) - The patch was reviewed here: https://reviews.llvm.org/D35782 and asides from the above (and moving some of the definition and expansion recognition logic into the corresponding state machines), I believe I incorporated all of Richard's suggestions. A few technicalities (most of which were clarified through private correspondence between rsmith, hubert and thomas) are worth mentioning. Given: #define F(a,...) a #__VA_OPT__(a ## a) a ## __VA_OPT__(__VA_ARGS__) - The call F(,) Does not supply any tokens for the variadic arguments and hence VA_OPT behaves as a placeholder. - When expanding VA_OPT (for e.g. F(,1) token pasting occurs eagerly within its contents if the contents need to be stringified. - A hash or a hashhash prior to VA_OPT does not inhibit expansion of arguments if they are the first token within VA_OPT. - When a variadic argument is supplied, argument substitution occurs within the contents as does stringification - and these resulting tokens are inserted back into the macro expansions token stream just prior to the entire stream being rescanned and concatenated. See wg21.link/P0306 for further details on the feature. Acknowledgment: This patch would have been poorer if not for Richard Smith's usual thoughtful analysis and feedback. llvm-svn: 315840
2017-10-15 09:26:26 +08:00
// Check for a valid macro arg identifier or __VA_OPT__.
if (!VAOCtx.isVAOptToken(Tok) &&
(Tok.getIdentifierInfo() == nullptr ||
MI->getParameterNum(Tok.getIdentifierInfo()) == -1)) {
Fix a couple of bugs: 1. When we accept "#garbage" in asm-with-cpp mode, change the token kind of the # to unknown so that the preprocessor won't try to process it as a real #. This fixes a crash on the attached example 2. Fix macro definition extents processing to handle #foo at the end of a macro to say the definition ends with the foo, not the #. This is a follow-on fix to r72283, and rdar://6916026 llvm-svn: 72388
2009-05-26 01:16:10 +08:00
// If this is assembler-with-cpp mode, we accept random gibberish after
// the '#' because '#' is often a comment character. However, change
// the kind of the token to tok::unknown so that the preprocessor isn't
// confused.
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (getLangOpts().AsmPreprocessor && Tok.isNot(tok::eod)) {
Fix a couple of bugs: 1. When we accept "#garbage" in asm-with-cpp mode, change the token kind of the # to unknown so that the preprocessor won't try to process it as a real #. This fixes a crash on the attached example 2. Fix macro definition extents processing to handle #foo at the end of a macro to say the definition ends with the foo, not the #. This is a follow-on fix to r72283, and rdar://6916026 llvm-svn: 72388
2009-05-26 01:16:10 +08:00
LastTok.setKind(tok::unknown);
Make sure the assembler-with-cpp hack for "#" works with multiple "#"s in succession. Fixes PR16363. llvm-svn: 184240
2013-06-19 05:33:38 +08:00
MI->AddTokenToBody(LastTok);
continue;
Fix a couple of bugs: 1. When we accept "#garbage" in asm-with-cpp mode, change the token kind of the # to unknown so that the preprocessor won't try to process it as a real #. This fixes a crash on the attached example 2. Fix macro definition extents processing to handle #foo at the end of a macro to say the definition ends with the foo, not the #. This is a follow-on fix to r72283, and rdar://6916026 llvm-svn: 72388
2009-05-26 01:16:10 +08:00
} else {
Diagnose missing macro argument following charize operator. For completeness, add a test-case for the equivalent stringize operator diagnostic too. llvm-svn: 265177
2016-04-02 03:02:20 +08:00
Diag(Tok, diag::err_pp_stringize_not_parameter)
<< LastTok.is(tok::hashat);
[NFC] Refactor the Preprocessor function that handles Macro definitions and rename Arguments to Parameters in Macro Definitions. - Extracted the reading of the tokens out into a separate function. - Replace 'Argument' with 'Parameter' when referring to the identifiers of the macro definition (as opposed to the supplied arguments - MacroArgs - during the macro invocation). This is in preparation for submitting patches for review to implement __VA_OPT__ which will otherwise just keep lengthening the HandleDefineDirective function and making it less comprehensible. I will also directly update some extra clang tooling that is broken by the change from Argument to Parameter. Hopefully the bots will stay appeased. Thanks! llvm-svn: 308190
2017-07-18 01:18:43 +08:00
return nullptr;
Fix a couple of bugs: 1. When we accept "#garbage" in asm-with-cpp mode, change the token kind of the # to unknown so that the preprocessor won't try to process it as a real #. This fixes a crash on the attached example 2. Fix macro definition extents processing to handle #foo at the end of a macro to say the definition ends with the foo, not the #. This is a follow-on fix to r72283, and rdar://6916026 llvm-svn: 72388
2009-05-26 01:16:10 +08:00
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fix a couple of bugs: 1. When we accept "#garbage" in asm-with-cpp mode, change the token kind of the # to unknown so that the preprocessor won't try to process it as a real #. This fixes a crash on the attached example 2. Fix macro definition extents processing to handle #foo at the end of a macro to say the definition ends with the foo, not the #. This is a follow-on fix to r72283, and rdar://6916026 llvm-svn: 72388
2009-05-26 01:16:10 +08:00
// Things look ok, add the '#' and param name tokens to the macro.
MI->AddTokenToBody(LastTok);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[c++2a] Implement P0306 __VA_OPT__ (Comma omission and comma deletion) This patch implements an extension to the preprocessor: __VA_OPT__(contents) --> which expands into its contents if variadic arguments are supplied to the parent macro, or behaves as an empty token if none. - Currently this feature is only enabled for C++2a (this could be enabled, with some careful tweaks, for other dialects with the appropriate extension or compatibility warnings) - The patch was reviewed here: https://reviews.llvm.org/D35782 and asides from the above (and moving some of the definition and expansion recognition logic into the corresponding state machines), I believe I incorporated all of Richard's suggestions. A few technicalities (most of which were clarified through private correspondence between rsmith, hubert and thomas) are worth mentioning. Given: #define F(a,...) a #__VA_OPT__(a ## a) a ## __VA_OPT__(__VA_ARGS__) - The call F(,) Does not supply any tokens for the variadic arguments and hence VA_OPT behaves as a placeholder. - When expanding VA_OPT (for e.g. F(,1) token pasting occurs eagerly within its contents if the contents need to be stringified. - A hash or a hashhash prior to VA_OPT does not inhibit expansion of arguments if they are the first token within VA_OPT. - When a variadic argument is supplied, argument substitution occurs within the contents as does stringification - and these resulting tokens are inserted back into the macro expansions token stream just prior to the entire stream being rescanned and concatenated. See wg21.link/P0306 for further details on the feature. Acknowledgment: This patch would have been poorer if not for Richard Smith's usual thoughtful analysis and feedback. llvm-svn: 315840
2017-10-15 09:26:26 +08:00
// If the token following '#' is VAOPT, let the next iteration handle it
// and check it for correctness, otherwise add the token and prime the
// loop with the next one.
if (!VAOCtx.isVAOptToken(Tok)) {
MI->AddTokenToBody(Tok);
LastTok = Tok;
// Get the next token of the macro.
LexUnexpandedToken(Tok);
}
}
if (VAOCtx.isInVAOpt()) {
assert(Tok.is(tok::eod) && "Must be at End Of preprocessing Directive");
Diag(Tok, diag::err_pp_expected_after)
<< LastTok.getKind() << tok::r_paren;
Diag(VAOCtx.getUnmatchedOpeningParenLoc(), diag::note_matching) << tok::l_paren;
return nullptr;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
}
[NFC] Refactor the Preprocessor function that handles Macro definitions and rename Arguments to Parameters in Macro Definitions. - Extracted the reading of the tokens out into a separate function. - Replace 'Argument' with 'Parameter' when referring to the identifiers of the macro definition (as opposed to the supplied arguments - MacroArgs - during the macro invocation). This is in preparation for submitting patches for review to implement __VA_OPT__ which will otherwise just keep lengthening the HandleDefineDirective function and making it less comprehensible. I will also directly update some extra clang tooling that is broken by the change from Argument to Parameter. Hopefully the bots will stay appeased. Thanks! llvm-svn: 308190
2017-07-18 01:18:43 +08:00
MI->setDefinitionEndLoc(LastTok.getLocation());
return MI;
}
/// HandleDefineDirective - Implements \#define. This consumes the entire macro
/// line then lets the caller lex the next real token.
void Preprocessor::HandleDefineDirective(
Token &DefineTok, const bool ImmediatelyAfterHeaderGuard) {
++NumDefined;
Token MacroNameTok;
bool MacroShadowsKeyword;
ReadMacroName(MacroNameTok, MU_Define, &MacroShadowsKeyword);
// Error reading macro name? If so, diagnostic already issued.
if (MacroNameTok.is(tok::eod))
return;
// If we are supposed to keep comments in #defines, reenable comment saving
// mode.
if (CurLexer) CurLexer->SetCommentRetentionState(KeepMacroComments);
MacroInfo *const MI = ReadOptionalMacroParameterListAndBody(
MacroNameTok, ImmediatelyAfterHeaderGuard);
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-31 03:24:48 +08:00
[NFC] Refactor the Preprocessor function that handles Macro definitions and rename Arguments to Parameters in Macro Definitions. - Extracted the reading of the tokens out into a separate function. - Replace 'Argument' with 'Parameter' when referring to the identifiers of the macro definition (as opposed to the supplied arguments - MacroArgs - during the macro invocation). This is in preparation for submitting patches for review to implement __VA_OPT__ which will otherwise just keep lengthening the HandleDefineDirective function and making it less comprehensible. I will also directly update some extra clang tooling that is broken by the change from Argument to Parameter. Hopefully the bots will stay appeased. Thanks! llvm-svn: 308190
2017-07-18 01:18:43 +08:00
if (!MI) return;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fixed warnings on redefine keywords and reserved ids. Repared support for warnings -Wkeyword-macro and -Wreserved-id-macro. The warning -Wkeyword-macro now is not issued in patterns that are used in configuration scripts: #define inline also for 'const', 'extern' and 'static'. If macro repalcement is identical to macro name, the warning also is not issued: #define volatile volatile And finally if macro replacement is also a keyword identical to the replaced one but decorated with leading/trailing underscores: #define inline __inline #define inline __inline__ #define inline _inline // in MSVC compatibility mode Warning -Wreserved-id-macro is off by default, it could help catching things like: #undef __cplusplus llvm-svn: 224512
2014-12-18 19:14:21 +08:00
if (MacroShadowsKeyword &&
!isConfigurationPattern(MacroNameTok, MI, getLangOpts())) {
Diag(MacroNameTok, diag::warn_pp_macro_hides_keyword);
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-31 03:24:48 +08:00
}
fix a bunch of comment typos found by codespell. Patch by Luis Felipe Strano Moraes! llvm-svn: 129559
2011-04-15 13:22:18 +08:00
// Check that there is no paste (##) operator at the beginning or end of the
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// replacement list.
unsigned NumTokens = MI->getNumTokens();
if (NumTokens != 0) {
if (MI->getReplacementToken(0).is(tok::hashhash)) {
Diag(MI->getReplacementToken(0), diag::err_paste_at_start);
return;
}
if (MI->getReplacementToken(NumTokens-1).is(tok::hashhash)) {
Diag(MI->getReplacementToken(NumTokens-1), diag::err_paste_at_end);
return;
}
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[clang-cl, PCH] Implement support for MS-style PCH through headers Implement support for MS-style PCH through headers. This enables support for /Yc and /Yu where the through header is either on the command line or included in the source. It replaces the current support the requires the header also be specified with /FI. This change adds a -cc1 option -pch-through-header that is used to either start or stop compilation during PCH create or use. When creating a PCH, the compilation ends after compilation of the through header. When using a PCH, tokens are skipped until after the through header is seen. Patch By: mikerice Differential Revision: https://reviews.llvm.org/D46652 llvm-svn: 336379
2018-07-06 01:22:13 +08:00
// When skipping just warn about macros that do not match.
if (SkippingUntilPCHThroughHeader) {
const MacroInfo *OtherMI = getMacroInfo(MacroNameTok.getIdentifierInfo());
if (!OtherMI || !MI->isIdenticalTo(*OtherMI, *this,
/*Syntactic=*/LangOpts.MicrosoftExt))
Diag(MI->getDefinitionLoc(), diag::warn_pp_macro_def_mismatch_with_pch)
<< MacroNameTok.getIdentifierInfo();
return;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Finally, if this identifier already had a macro defined for it, verify that
Keep history of macro definitions and #undefs Summary: Summary: Keep history of macro definitions and #undefs with corresponding source locations, so that we can later find out all macros active in a specified source location. We don't save the history in PCH (no need currently). Memory overhead is about sizeof(void*)*3*<number of macro definitions and #undefs>+<in-memory size of all #undef'd macros> I've run a test on a file composed of 109 .h files from boost 1.49 on x86-64 linux. Stats before this patch: *** Preprocessor Stats: 73222 directives found: 19171 #define. 4345 #undef. #include/#include_next/#import: 5233 source files entered. 27 max include stack depth 19210 #if/#ifndef/#ifdef. 2384 #else/#elif. 6891 #endif. 408 #pragma. 14466 #if/#ifndef#ifdef regions skipped 80023/451669/1270 obj/fn/builtin macros expanded, 85724 on the fast path. 127145 token paste (##) operations performed, 11008 on the fast path. Preprocessor Memory: 5874615B total BumpPtr: 4399104 Macro Expanded Tokens: 417768 Predefines Buffer: 8135 Macros: 1048576 #pragma push_macro Info: 0 Poison Reasons: 1024 Comment Handlers: 8 Stats with this patch: ... Preprocessor Memory: 7541687B total BumpPtr: 6066176 Macro Expanded Tokens: 417768 Predefines Buffer: 8135 Macros: 1048576 #pragma push_macro Info: 0 Poison Reasons: 1024 Comment Handlers: 8 In my test increase in memory usage is about 1.7Mb, which is ~28% of initial preprocessor's memory usage and about 0.8% of clang's total VMM allocation. As for CPU overhead, it should only be noticeable when iterating over all macros, and should mostly consist of couple extra dereferences and one comparison per macro + skipping of #undef'd macros. It's less trivial to measure, though, as the preprocessor consumes a very small fraction of compilation time. Reviewers: doug.gregor, klimek, rsmith, djasper Reviewed By: doug.gregor CC: cfe-commits, chandlerc Differential Revision: http://llvm-reviews.chandlerc.com/D28 llvm-svn: 162810
2012-08-29 08:20:03 +08:00
// the macro bodies are identical, and issue diagnostics if they are not.
[preprocessor] Split the MacroInfo class into two separate concepts, MacroInfo class for the data specific to a macro definition (e.g. what the tokens are), and MacroDirective class which encapsulates the changes to the "macro namespace" (e.g. the location where the macro name became active, the location where it was undefined, etc.) (A MacroDirective always points to a MacroInfo object.) Usually a macro definition (MacroInfo) is where a macro name becomes active (MacroDirective) but splitting the concepts allows us to better model the effect of modules to the macro namespace (also as a bonus it allows better modeling of push_macro/pop_macro #pragmas). Modules can have their own macro history, separate from the local (current translation unit) macro history; MacroDirectives will be used to model the macro history (changes to macro namespace). For example, if "@import A;" imports macro FOO, there will be a new local MacroDirective created to indicate that "FOO" became active at the import location. Module "A" itself will contain another MacroDirective in its macro history (at the point of the definition of FOO) and both MacroDirectives will point to the same MacroInfo object. Introducing the separation of macro concepts is the first part towards better modeling of module macros. llvm-svn: 175585
2013-02-20 08:54:57 +08:00
if (const MacroInfo *OtherMI=getMacroInfo(MacroNameTok.getIdentifierInfo())) {
In Objective-C, ignore attempts to redefine the ARC/GC qualifier macros. This works around existing system headers which unconditionally redefine these macros. This is reasonably safe to do because we used to warn about it anyway (outside of system headers). Continue to warn if the redefinition would have changed the expansion. Still permit redefinition if the macro is explicitly #undef'ed first. rdar://23788307 llvm-svn: 255311
2015-12-11 07:31:01 +08:00
// In Objective-C, ignore attempts to directly redefine the builtin
// definitions of the ownership qualifiers. It's still possible to
// #undef them.
auto isObjCProtectedMacro = [](const IdentifierInfo *II) -> bool {
return II->isStr("__strong") ||
II->isStr("__weak") ||
II->isStr("__unsafe_unretained") ||
II->isStr("__autoreleasing");
};
NFC: Remove the ObjC1/ObjC2 distinction from clang (and related projects) We haven't supported compiling ObjC1 for a long time (and never will again), so there isn't any reason to keep these separate. This patch replaces LangOpts::ObjC1 and LangOpts::ObjC2 with LangOpts::ObjC. Differential revision: https://reviews.llvm.org/D53547 llvm-svn: 345637
2018-10-31 04:31:30 +08:00
if (getLangOpts().ObjC &&
In Objective-C, ignore attempts to redefine the ARC/GC qualifier macros. This works around existing system headers which unconditionally redefine these macros. This is reasonably safe to do because we used to warn about it anyway (outside of system headers). Continue to warn if the redefinition would have changed the expansion. Still permit redefinition if the macro is explicitly #undef'ed first. rdar://23788307 llvm-svn: 255311
2015-12-11 07:31:01 +08:00
SourceMgr.getFileID(OtherMI->getDefinitionLoc())
== getPredefinesFileID() &&
isObjCProtectedMacro(MacroNameTok.getIdentifierInfo())) {
// Warn if it changes the tokens.
if ((!getDiagnostics().getSuppressSystemWarnings() ||
!SourceMgr.isInSystemHeader(DefineTok.getLocation())) &&
!MI->isIdenticalTo(*OtherMI, *this,
/*Syntactic=*/LangOpts.MicrosoftExt)) {
Diag(MI->getDefinitionLoc(), diag::warn_pp_objc_macro_redef_ignored);
}
assert(!OtherMI->isWarnIfUnused());
return;
}
As a performance optimization, don't bother calling MacroInfo::isIdenticalTo if warnings in system headers are disabled. isIdenticalTo can end up calling the expensive getSpelling method, and other bad stuff and is completely unneeded if the warning will be discarded anyway. rdar://6502956 llvm-svn: 62347
2009-01-17 03:50:11 +08:00
// It is very common for system headers to have tons of macro redefinitions
// and for warnings to be disabled in system headers. If this is the case,
// then don't bother calling MacroInfo::isIdenticalTo.
use accessor instead of poking ivar directly llvm-svn: 66954
2009-03-14 05:17:23 +08:00
if (!getDiagnostics().getSuppressSystemWarnings() ||
As a performance optimization, don't bother calling MacroInfo::isIdenticalTo if warnings in system headers are disabled. isIdenticalTo can end up calling the expensive getSpelling method, and other bad stuff and is completely unneeded if the warning will be discarded anyway. rdar://6502956 llvm-svn: 62347
2009-01-17 03:50:11 +08:00
!SourceMgr.isInSystemHeader(DefineTok.getLocation())) {
When redefining a macro don't warn twice if it's not used and don't warn for duplicate definition by command line options. Fixes rdar://8875916. llvm-svn: 123767
2011-01-19 03:50:15 +08:00
if (!OtherMI->isUsed() && OtherMI->isWarnIfUnused())
As a performance optimization, don't bother calling MacroInfo::isIdenticalTo if warnings in system headers are disabled. isIdenticalTo can end up calling the expensive getSpelling method, and other bad stuff and is completely unneeded if the warning will be discarded anyway. rdar://6502956 llvm-svn: 62347
2009-01-17 03:50:11 +08:00
Diag(OtherMI->getDefinitionLoc(), diag::pp_macro_not_used);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Patch for r272584 (http://reviews.llvm.org/rL272584) to address clang-x64-ninja-win7 buildbot failure. Patch by Eric Niebler llvm-svn: 272592
2016-06-14 05:55:33 +08:00
// Warn if defining "__LINE__" and other builtins, per C99 6.10.8/4 and
After issuing a diagnostic for undefining or redefining a builtin macro, continue parsing the directive rather than silently discarding it. Allowing undef or redef of __TIME__ and __DATE__ is important to folks who want stable, reproducible builds. llvm-svn: 176540
2013-03-06 08:46:00 +08:00
// C++ [cpp.predefined]p4, but allow it as an extension.
if (OtherMI->isBuiltinMacro())
Diag(MacroNameTok, diag::ext_pp_redef_builtin_macro);
Implement #pragma push_macro, patch by Francois Pichet! llvm-svn: 111234
2010-08-17 23:55:45 +08:00
// Macros must be identical. This means all tokens and whitespace
[preprocessor] Allow comparing two macro definitions syntactically instead of only lexically. Syntactically means the function macro parameter names do not need to use the same identifiers in order for the definitions to be considered identical. Syntactic equivalence is a microsoft extension for macro redefinitions and we'll also use this kind of comparison to check for ambiguous macros coming from modules. rdar://13562254 llvm-svn: 178671
2013-04-04 01:39:30 +08:00
// separation must be the same. C99 6.10.3p2.
After issuing a diagnostic for undefining or redefining a builtin macro, continue parsing the directive rather than silently discarding it. Allowing undef or redef of __TIME__ and __DATE__ is important to folks who want stable, reproducible builds. llvm-svn: 176540
2013-03-06 08:46:00 +08:00
else if (!OtherMI->isAllowRedefinitionsWithoutWarning() &&
[preprocessor] Allow comparing two macro definitions syntactically instead of only lexically. Syntactically means the function macro parameter names do not need to use the same identifiers in order for the definitions to be considered identical. Syntactic equivalence is a microsoft extension for macro redefinitions and we'll also use this kind of comparison to check for ambiguous macros coming from modules. rdar://13562254 llvm-svn: 178671
2013-04-04 01:39:30 +08:00
!MI->isIdenticalTo(*OtherMI, *this, /*Syntactic=*/LangOpts.MicrosoftExt)) {
As a performance optimization, don't bother calling MacroInfo::isIdenticalTo if warnings in system headers are disabled. isIdenticalTo can end up calling the expensive getSpelling method, and other bad stuff and is completely unneeded if the warning will be discarded anyway. rdar://6502956 llvm-svn: 62347
2009-01-17 03:50:11 +08:00
Diag(MI->getDefinitionLoc(), diag::ext_pp_macro_redef)
<< MacroNameTok.getIdentifierInfo();
Diag(OtherMI->getDefinitionLoc(), diag::note_previous_definition);
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
When redefining a macro don't warn twice if it's not used and don't warn for duplicate definition by command line options. Fixes rdar://8875916. llvm-svn: 123767
2011-01-19 03:50:15 +08:00
if (OtherMI->isWarnIfUnused())
WarnUnusedMacroLocs.erase(OtherMI->getDefinitionLoc());
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[Preprocessor/Modules] Separate the macro directives kinds into their own MacroDirective's subclasses. For each macro directive (define, undefine, visibility) have a separate object that gets chained to the macro directive history. This has several benefits: -No need to mutate a MacroDirective when there is a undefine/visibility directive. Stuff like PPMutationListener become unnecessary. -No need to keep extra source locations for the undef/visibility locations for the define directive object (which is the majority of the directives) -Much easier to hide/unhide a section in the macro directive history. -Easier to track the effects of the directives across different submodules. llvm-svn: 178037
2013-03-27 01:17:01 +08:00
DefMacroDirective *MD =
appendDefMacroDirective(MacroNameTok.getIdentifierInfo(), MI);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fix diagnostic pragmas. Diagnostic pragmas are broken because we don't keep track of the diagnostic state changes and we only check the current/latest state. Problems manifest if a diagnostic is emitted for a source line that has different diagnostic state than the current state; this can affect a lot of places, like C++ inline methods, template instantiations, the lexer, etc. Fix the issue by having the Diagnostic object keep track of the source location of the pragmas so that it is able to know what is the diagnostic state at any given source location. Fixes rdar://8365684. llvm-svn: 121873
2010-12-16 02:44:22 +08:00
assert(!MI->isUsed());
// If we need warning for not using the macro, add its location in the
// warn-because-unused-macro set. If it gets used it will be removed from set.
Split isFromMainFile into two functions. Basically, isInMainFile considers line markers, and isWrittenInMainFile doesn't. Distinguishing between the two is useful when dealing with files which are preprocessed files or rewritten with -frewrite-includes (so we don't, for example, print useless warnings). llvm-svn: 188968
2013-08-22 08:27:10 +08:00
if (getSourceManager().isInMainFile(MI->getDefinitionLoc()) &&
Hide the concept of diagnostic levels from lex, parse and sema The compilation pipeline doesn't actually need to know about the high-level concept of diagnostic mappings, and hiding the final computed level presents several simplifications and other potential benefits. The only exceptions are opportunistic checks to see whether expensive code paths can be avoided for diagnostics that are guaranteed to be ignored at a certain SourceLocation. This commit formalizes that invariant by introducing and using DiagnosticsEngine::isIgnored() in place of individual level checks throughout lex, parse and sema. llvm-svn: 211005
2014-06-16 07:30:39 +08:00
!Diags->isIgnored(diag::pp_macro_not_used, MI->getDefinitionLoc())) {
Fix diagnostic pragmas. Diagnostic pragmas are broken because we don't keep track of the diagnostic state changes and we only check the current/latest state. Problems manifest if a diagnostic is emitted for a source line that has different diagnostic state than the current state; this can affect a lot of places, like C++ inline methods, template instantiations, the lexer, etc. Fix the issue by having the Diagnostic object keep track of the source location of the pragmas so that it is able to know what is the diagnostic state at any given source location. Fixes rdar://8365684. llvm-svn: 121873
2010-12-16 02:44:22 +08:00
MI->setIsWarnIfUnused(true);
WarnUnusedMacroLocs.insert(MI->getDefinitionLoc());
}
add a ppcallback hook for macro definitions. llvm-svn: 68883
2009-04-12 09:39:54 +08:00
// If the callbacks want to know, tell them about the macro definition.
if (Callbacks)
[preprocessor] Use MacroDirective in the preprocessor callbacks to make available the full information about the macro (e.g if it was imported and where). llvm-svn: 175978
2013-02-24 08:05:14 +08:00
Callbacks->MacroDefined(MacroNameTok, MD);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
Documentation cleanup: * Add \brief summaries; * Escape # characters in Doxygen comments; * Add \code...\endcode markup for code examples; * Add \verbatim...\endverbatim markup for grammar productions. llvm-svn: 158976
2012-06-22 13:46:07 +08:00
/// HandleUndefDirective - Implements \#undef.
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
///
PP: Remove unused parameters from methods NFC Differential Revision: http://reviews.llvm.org/D25938 llvm-svn: 285180
2016-10-26 16:52:41 +08:00
void Preprocessor::HandleUndefDirective() {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
++NumUndefined;
Token MacroNameTok;
Use enumerators instead of hardcoded integers when processing macro names. llvm-svn: 220572
2014-10-25 01:31:32 +08:00
ReadMacroName(MacroNameTok, MU_Undef);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Error reading macro name? If so, diagnostic already issued.
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
if (MacroNameTok.is(tok::eod))
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
return;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Check to see if this is the last token on the #undef line.
Fix the #import / #include_next "extra tokens at end of #foo directive" Warning to properly report that it is an import/include_next instead of claiming it is a #include. llvm-svn: 69023
2009-04-14 13:07:49 +08:00
CheckEndOfDirective("undef");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[modules] Stop trying to fake up a linear MacroDirective history. Modules builds fundamentally have a non-linear macro history. In the interest of better source fidelity, represent the macro definition information faithfully: we have a linear macro directive history within each module, and at any point we have a unique "latest" local macro directive and a collection of visible imported directives. This also removes the attendent complexity of attempting to create a correct MacroDirective history (which we got wrong in the general case). No functionality change intended. llvm-svn: 236176
2015-04-30 07:20:19 +08:00
// Okay, we have a valid identifier to undef.
auto *II = MacroNameTok.getIdentifierInfo();
Switch PPCallbacks to take the new MacroDefinition instead of MacroDirective*, in order to preserve full information on module macro expansion. llvm-svn: 236404
2015-05-04 11:15:40 +08:00
auto MD = getMacroDefinition(II);
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
UndefMacroDirective *Undef = nullptr;
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-31 03:24:48 +08:00
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
// If the macro is not defined, this is a noop undef.
if (const MacroInfo *MI = MD.getMacroInfo()) {
if (!MI->isUsed() && MI->isWarnIfUnused())
Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used);
if (MI->isWarnIfUnused())
WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
Undef = AllocateUndefMacroDirective(MacroNameTok.getLocation());
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[preprocessor] Call the MacroUndefined callback even when the macro was not defined. Patch by Enea Zaffanella! llvm-svn: 172623
2013-01-17 00:52:44 +08:00
// If the callbacks want to know, tell them about the macro #undef.
// Note: no matter if the macro was defined or not.
Switch PPCallbacks to take the new MacroDefinition instead of MacroDirective*, in order to preserve full information on module macro expansion. llvm-svn: 236404
2015-05-04 11:15:40 +08:00
if (Callbacks)
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
Callbacks->MacroUndefined(MacroNameTok, MD, Undef);
Fix diagnostic pragmas. Diagnostic pragmas are broken because we don't keep track of the diagnostic state changes and we only check the current/latest state. Problems manifest if a diagnostic is emitted for a source line that has different diagnostic state than the current state; this can affect a lot of places, like C++ inline methods, template instantiations, the lexer, etc. Fix the issue by having the Diagnostic object keep track of the source location of the pragmas so that it is able to know what is the diagnostic state at any given source location. Fixes rdar://8365684. llvm-svn: 121873
2010-12-16 02:44:22 +08:00
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
if (Undef)
appendMacroDirective(II, Undef);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
//===----------------------------------------------------------------------===//
// Preprocessor Conditional Directive Handling.
//===----------------------------------------------------------------------===//
Documentation cleanup: * Add \brief summaries; * Escape # characters in Doxygen comments; * Add \code...\endcode markup for code examples; * Add \verbatim...\endverbatim markup for grammar productions. llvm-svn: 158976
2012-06-22 13:46:07 +08:00
/// HandleIfdefDirective - Implements the \#ifdef/\#ifndef directive. isIfndef
/// is true when this is a \#ifndef directive. ReadAnyTokensBeforeDirective is
/// true if any tokens have been returned or pp-directives activated before this
/// \#ifndef has been lexed.
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
///
[Lexer] Report more precise skipped regions (PR34166) This patch teaches the preprocessor to report more precise source ranges for code that is skipped due to conditional directives. The new behavior includes the '#' from the opening directive and the full text of the line containing the closing directive in the skipped area. This matches up clang's behavior (we don't IRGen the code between the closing "endif" and the end of a line). This also affects the code coverage implementation. See llvm.org/PR34166 (this also happens to be rdar://problem/23224058). The old behavior (report the end of the skipped range as the end location of the 'endif' token) is preserved for indexing clients. Differential Revision: https://reviews.llvm.org/D36642 llvm-svn: 312947
2017-09-12 04:47:42 +08:00
void Preprocessor::HandleIfdefDirective(Token &Result,
const Token &HashToken,
bool isIfndef,
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
bool ReadAnyTokensBeforeDirective) {
++NumIf;
Token DirectiveTok = Result;
Token MacroNameTok;
ReadMacroName(MacroNameTok);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Error reading macro name? If so, diagnostic already issued.
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
if (MacroNameTok.is(tok::eod)) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Skip code until we get to #endif. This helps with recovery by not
// emitting an error when the #endif is reached.
[preamble] Also record the "skipping" state of the preprocessor When a preamble ends in a conditional preprocessor block that is being skipped, the preprocessor needs to continue skipping that block when the preamble is used. This fixes PR34570. llvm-svn: 317308
2017-11-03 17:40:07 +08:00
SkipExcludedConditionalBlock(HashToken.getLocation(),
DirectiveTok.getLocation(),
[Lexer] Report more precise skipped regions (PR34166) This patch teaches the preprocessor to report more precise source ranges for code that is skipped due to conditional directives. The new behavior includes the '#' from the opening directive and the full text of the line containing the closing directive in the skipped area. This matches up clang's behavior (we don't IRGen the code between the closing "endif" and the end of a line). This also affects the code coverage implementation. See llvm.org/PR34166 (this also happens to be rdar://problem/23224058). The old behavior (report the end of the skipped range as the end location of the 'endif' token) is preserved for indexing clients. Differential Revision: https://reviews.llvm.org/D36642 llvm-svn: 312947
2017-09-12 04:47:42 +08:00
/*Foundnonskip*/ false, /*FoundElse*/ false);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
return;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Check to see if this is the last token on the #if[n]def line.
Fix the #import / #include_next "extra tokens at end of #foo directive" Warning to properly report that it is an import/include_next instead of claiming it is a #include. llvm-svn: 69023
2009-04-14 13:07:49 +08:00
CheckEndOfDirective(isIfndef ? "ifndef" : "ifdef");
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Fix PR6282: the include guard optimization cannot happen if the guard macro is already defined for the first occurrence of the header. If it is, the body will be skipped and not be properly analyzed for the include guard optimization. llvm-svn: 95972
2010-02-12 16:03:27 +08:00
IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();
Switch PPCallbacks to take the new MacroDefinition instead of MacroDirective*, in order to preserve full information on module macro expansion. llvm-svn: 236404
2015-05-04 11:15:40 +08:00
auto MD = getMacroDefinition(MII);
MacroInfo *MI = MD.getMacroInfo();
Use SmallString instead of SmallVector llvm-svn: 98436
2010-03-13 18:17:05 +08:00
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
if (CurPPLexer->getConditionalStackDepth() == 0) {
Fix PR6282: the include guard optimization cannot happen if the guard macro is already defined for the first occurrence of the header. If it is, the body will be skipped and not be properly analyzed for the include guard optimization. llvm-svn: 95972
2010-02-12 16:03:27 +08:00
// If the start of a top-level #ifdef and if the macro is not defined,
// inform MIOpt that this might be the start of a proper include guard.
// Otherwise it is some other form of unknown conditional which we can't
// handle.
[C++11] Use 'nullptr'. Lex edition. llvm-svn: 209083
2014-05-18 07:10:59 +08:00
if (!ReadAnyTokensBeforeDirective && !MI) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
assert(isIfndef && "#ifdef shouldn't reach here");
Introducing -Wheader-guard, a warning that checks header guards actually work properly. This warning checks that the #ifndef and #define directives at the beginning of a header refer to the same macro name. Includes a fix-it hint to correct the header guard. llvm-svn: 183867
2013-06-13 05:20:57 +08:00
CurPPLexer->MIOpt.EnterTopLevelIfndef(MII, MacroNameTok.getLocation());
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
} else
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
CurPPLexer->MIOpt.EnterTopLevelConditional();
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
// If there is a macro, process it.
if (MI) // Mark it used.
Fix diagnostic pragmas. Diagnostic pragmas are broken because we don't keep track of the diagnostic state changes and we only check the current/latest state. Problems manifest if a diagnostic is emitted for a source line that has different diagnostic state than the current state; this can affect a lot of places, like C++ inline methods, template instantiations, the lexer, etc. Fix the issue by having the Diagnostic object keep track of the source location of the pragmas so that it is able to know what is the diagnostic state at any given source location. Fixes rdar://8365684. llvm-svn: 121873
2010-12-16 02:44:22 +08:00
markMacroAsUsed(MI);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[preprocessor] Enhance the preprocessor callbacks: -Add location parameter for the directives callbacks -Skip callbacks if the directive is inside a skipped range. -Make sure the directive callbacks are invoked in source order. llvm-svn: 152017
2012-03-05 13:48:09 +08:00
if (Callbacks) {
if (isIfndef)
[preprocessor] Use MacroDirective in the preprocessor callbacks to make available the full information about the macro (e.g if it was imported and where). llvm-svn: 175978
2013-02-24 08:05:14 +08:00
Callbacks->Ifndef(DirectiveTok.getLocation(), MacroNameTok, MD);
[preprocessor] Enhance the preprocessor callbacks: -Add location parameter for the directives callbacks -Skip callbacks if the directive is inside a skipped range. -Make sure the directive callbacks are invoked in source order. llvm-svn: 152017
2012-03-05 13:48:09 +08:00
else
[preprocessor] Use MacroDirective in the preprocessor callbacks to make available the full information about the macro (e.g if it was imported and where). llvm-svn: 175978
2013-02-24 08:05:14 +08:00
Callbacks->Ifdef(DirectiveTok.getLocation(), MacroNameTok, MD);
[preprocessor] Enhance the preprocessor callbacks: -Add location parameter for the directives callbacks -Skip callbacks if the directive is inside a skipped range. -Make sure the directive callbacks are invoked in source order. llvm-svn: 152017
2012-03-05 13:48:09 +08:00
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Should we include the stuff contained by this directive?
[preprocessor] When preprocessor option 'SingleFileParseMode' is enabled, parse all directive blocks if the condition uses undefined macros This is useful for being able to parse the preprocessor directive blocks even if the header, that defined the macro that is checked, hasn't been included. Differential Revision: https://reviews.llvm.org/D34263 llvm-svn: 305797
2017-06-20 22:36:58 +08:00
if (PPOpts->SingleFileParseMode && !MI) {
// In 'single-file-parse mode' undefined identifiers trigger parsing of all
// the directive blocks.
CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(),
[preprocessor] Fix assertion hit when 'SingleFileParseMode' option is enabled and #if with an undefined identifier and without #else 'HandleEndifDirective' asserts that 'WasSkipping' is false, so switch to using 'FoundNonSkip' as the hint for 'SingleFileParseMode' to keep going with parsing. llvm-svn: 305940
2017-06-22 02:52:44 +08:00
/*wasskip*/false, /*foundnonskip*/false,
[preprocessor] When preprocessor option 'SingleFileParseMode' is enabled, parse all directive blocks if the condition uses undefined macros This is useful for being able to parse the preprocessor directive blocks even if the header, that defined the macro that is checked, hasn't been included. Differential Revision: https://reviews.llvm.org/D34263 llvm-svn: 305797
2017-06-20 22:36:58 +08:00
/*foundelse*/false);
} else if (!MI == isIfndef) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Yes, remember that we are inside a conditional, then lex the next token.
formatting changes. llvm-svn: 91263
2009-12-14 12:54:40 +08:00
CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(),
/*wasskip*/false, /*foundnonskip*/true,
/*foundelse*/false);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
} else {
Add PPCallbacks for #if/#ifdef/etc. The callback info for #if/#elif is not great -- ideally it would give us a list of tokens in the #if, or even better, a little parse tree. But that's a lot more work. Instead, clients can retokenize using Lexer::LexFromRawLexer(). Reviewed by nlewycky. llvm-svn: 118318
2010-11-06 09:19:03 +08:00
// No, skip the contents of this block.
[preamble] Also record the "skipping" state of the preprocessor When a preamble ends in a conditional preprocessor block that is being skipped, the preprocessor needs to continue skipping that block when the preamble is used. This fixes PR34570. llvm-svn: 317308
2017-11-03 17:40:07 +08:00
SkipExcludedConditionalBlock(HashToken.getLocation(),
DirectiveTok.getLocation(),
[Lexer] Report more precise skipped regions (PR34166) This patch teaches the preprocessor to report more precise source ranges for code that is skipped due to conditional directives. The new behavior includes the '#' from the opening directive and the full text of the line containing the closing directive in the skipped area. This matches up clang's behavior (we don't IRGen the code between the closing "endif" and the end of a line). This also affects the code coverage implementation. See llvm.org/PR34166 (this also happens to be rdar://problem/23224058). The old behavior (report the end of the skipped range as the end location of the 'endif' token) is preserved for indexing clients. Differential Revision: https://reviews.llvm.org/D36642 llvm-svn: 312947
2017-09-12 04:47:42 +08:00
/*Foundnonskip*/ false,
/*FoundElse*/ false);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
}
Documentation cleanup: * Add \brief summaries; * Escape # characters in Doxygen comments; * Add \code...\endcode markup for code examples; * Add \verbatim...\endverbatim markup for grammar productions. llvm-svn: 158976
2012-06-22 13:46:07 +08:00
/// HandleIfDirective - Implements the \#if directive.
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
///
void Preprocessor::HandleIfDirective(Token &IfToken,
[Lexer] Report more precise skipped regions (PR34166) This patch teaches the preprocessor to report more precise source ranges for code that is skipped due to conditional directives. The new behavior includes the '#' from the opening directive and the full text of the line containing the closing directive in the skipped area. This matches up clang's behavior (we don't IRGen the code between the closing "endif" and the end of a line). This also affects the code coverage implementation. See llvm.org/PR34166 (this also happens to be rdar://problem/23224058). The old behavior (report the end of the skipped range as the end location of the 'endif' token) is preserved for indexing clients. Differential Revision: https://reviews.llvm.org/D36642 llvm-svn: 312947
2017-09-12 04:47:42 +08:00
const Token &HashToken,
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
bool ReadAnyTokensBeforeDirective) {
++NumIf;
Remove random windows line endings that snuck into the middle of this code. llvm-svn: 351633
2019-01-19 14:36:00 +08:00
// Parse and evaluate the conditional expression.
IdentifierInfo *IfNDefMacro = nullptr;
const DirectiveEvalResult DER = EvaluateDirectiveExpression(IfNDefMacro);
const bool ConditionalTrue = DER.Conditional;
// If this condition is equivalent to #ifndef X, and if this is the first
// directive seen, handle it for the multiple-include optimization.
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
if (CurPPLexer->getConditionalStackDepth() == 0) {
Fix PR6282: the include guard optimization cannot happen if the guard macro is already defined for the first occurrence of the header. If it is, the body will be skipped and not be properly analyzed for the include guard optimization. llvm-svn: 95972
2010-02-12 16:03:27 +08:00
if (!ReadAnyTokensBeforeDirective && IfNDefMacro && ConditionalTrue)
PR16339: Don't produce a diagnostic pointing at the whitespace between a '#if' and a '!defined(X)' if we find a broken header guard. This is suboptimal; we should point the diagnostic at the 'X' token not the 'if' token, but it fixes the crash. llvm-svn: 184054
2013-06-16 13:05:39 +08:00
// FIXME: Pass in the location of the macro name, not the 'if' token.
CurPPLexer->MIOpt.EnterTopLevelIfndef(IfNDefMacro, IfToken.getLocation());
fix PR2357 (#ifs didnt invalidate the multiple-inclusion optimization state) llvm-svn: 51843
2008-06-02 02:31:24 +08:00
else
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
CurPPLexer->MIOpt.EnterTopLevelConditional();
Remove random windows line endings that snuck into the middle of this code. llvm-svn: 351633
2019-01-19 14:36:00 +08:00
}
if (Callbacks)
Callbacks->If(
IfToken.getLocation(), DER.ExprRange,
(ConditionalTrue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False));
// Should we include the stuff contained by this directive?
if (PPOpts->SingleFileParseMode && DER.IncludedUndefinedIds) {
[preprocessor] When preprocessor option 'SingleFileParseMode' is enabled, parse all directive blocks if the condition uses undefined macros This is useful for being able to parse the preprocessor directive blocks even if the header, that defined the macro that is checked, hasn't been included. Differential Revision: https://reviews.llvm.org/D34263 llvm-svn: 305797
2017-06-20 22:36:58 +08:00
// In 'single-file-parse mode' undefined identifiers trigger parsing of all
// the directive blocks.
[preprocessor] Fix assertion hit when 'SingleFileParseMode' option is enabled and #if with an undefined identifier and without #else 'HandleEndifDirective' asserts that 'WasSkipping' is false, so switch to using 'FoundNonSkip' as the hint for 'SingleFileParseMode' to keep going with parsing. llvm-svn: 305940
2017-06-22 02:52:44 +08:00
CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false,
[preprocessor] When preprocessor option 'SingleFileParseMode' is enabled, parse all directive blocks if the condition uses undefined macros This is useful for being able to parse the preprocessor directive blocks even if the header, that defined the macro that is checked, hasn't been included. Differential Revision: https://reviews.llvm.org/D34263 llvm-svn: 305797
2017-06-20 22:36:58 +08:00
/*foundnonskip*/false, /*foundelse*/false);
} else if (ConditionalTrue) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Yes, remember that we are inside a conditional, then lex the next token.
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false,
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
/*foundnonskip*/true, /*foundelse*/false);
} else {
Add PPCallbacks for #if/#ifdef/etc. The callback info for #if/#elif is not great -- ideally it would give us a list of tokens in the #if, or even better, a little parse tree. But that's a lot more work. Instead, clients can retokenize using Lexer::LexFromRawLexer(). Reviewed by nlewycky. llvm-svn: 118318
2010-11-06 09:19:03 +08:00
// No, skip the contents of this block.
[preamble] Also record the "skipping" state of the preprocessor When a preamble ends in a conditional preprocessor block that is being skipped, the preprocessor needs to continue skipping that block when the preamble is used. This fixes PR34570. llvm-svn: 317308
2017-11-03 17:40:07 +08:00
SkipExcludedConditionalBlock(HashToken.getLocation(), IfToken.getLocation(),
[Lexer] Report more precise skipped regions (PR34166) This patch teaches the preprocessor to report more precise source ranges for code that is skipped due to conditional directives. The new behavior includes the '#' from the opening directive and the full text of the line containing the closing directive in the skipped area. This matches up clang's behavior (we don't IRGen the code between the closing "endif" and the end of a line). This also affects the code coverage implementation. See llvm.org/PR34166 (this also happens to be rdar://problem/23224058). The old behavior (report the end of the skipped range as the end location of the 'endif' token) is preserved for indexing clients. Differential Revision: https://reviews.llvm.org/D36642 llvm-svn: 312947
2017-09-12 04:47:42 +08:00
/*Foundnonskip*/ false,
/*FoundElse*/ false);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
}
Documentation cleanup: * Add \brief summaries; * Escape # characters in Doxygen comments; * Add \code...\endcode markup for code examples; * Add \verbatim...\endverbatim markup for grammar productions. llvm-svn: 158976
2012-06-22 13:46:07 +08:00
/// HandleEndifDirective - Implements the \#endif directive.
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
///
void Preprocessor::HandleEndifDirective(Token &EndifToken) {
++NumEndif;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Check that this is the whole directive.
Fix the #import / #include_next "extra tokens at end of #foo directive" Warning to properly report that it is an import/include_next instead of claiming it is a #include. llvm-svn: 69023
2009-04-14 13:07:49 +08:00
CheckEndOfDirective("endif");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
PPConditionalInfo CondInfo;
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
if (CurPPLexer->popConditionalLevel(CondInfo)) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// No conditionals on the stack: this is an #endif without an #if.
Convert the lexer and start converting the PP over to using canonical Diag methods. llvm-svn: 59511
2008-11-18 15:59:24 +08:00
Diag(EndifToken, diag::err_pp_endif_without_if);
return;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// If this the end of a top-level #endif, inform MIOpt.
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
if (CurPPLexer->getConditionalStackDepth() == 0)
CurPPLexer->MIOpt.ExitTopLevelConditional();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
assert(!CondInfo.WasSkipping && !CurPPLexer->LexingRawMode &&
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
"This code should only be reachable in the non-skipping case!");
Add PPCallbacks for #if/#ifdef/etc. The callback info for #if/#elif is not great -- ideally it would give us a list of tokens in the #if, or even better, a little parse tree. But that's a lot more work. Instead, clients can retokenize using Lexer::LexFromRawLexer(). Reviewed by nlewycky. llvm-svn: 118318
2010-11-06 09:19:03 +08:00
if (Callbacks)
[preprocessor] Enhance the preprocessor callbacks: -Add location parameter for the directives callbacks -Skip callbacks if the directive is inside a skipped range. -Make sure the directive callbacks are invoked in source order. llvm-svn: 152017
2012-03-05 13:48:09 +08:00
Callbacks->Endif(EndifToken.getLocation(), CondInfo.IfLoc);
Add PPCallbacks for #if/#ifdef/etc. The callback info for #if/#elif is not great -- ideally it would give us a list of tokens in the #if, or even better, a little parse tree. But that's a lot more work. Instead, clients can retokenize using Lexer::LexFromRawLexer(). Reviewed by nlewycky. llvm-svn: 118318
2010-11-06 09:19:03 +08:00
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Documentation cleanup: * Add \brief summaries; * Escape # characters in Doxygen comments; * Add \code...\endcode markup for code examples; * Add \verbatim...\endverbatim markup for grammar productions. llvm-svn: 158976
2012-06-22 13:46:07 +08:00
/// HandleElseDirective - Implements the \#else directive.
Add PPCallbacks for #if/#ifdef/etc. The callback info for #if/#elif is not great -- ideally it would give us a list of tokens in the #if, or even better, a little parse tree. But that's a lot more work. Instead, clients can retokenize using Lexer::LexFromRawLexer(). Reviewed by nlewycky. llvm-svn: 118318
2010-11-06 09:19:03 +08:00
///
[Lexer] Report more precise skipped regions (PR34166) This patch teaches the preprocessor to report more precise source ranges for code that is skipped due to conditional directives. The new behavior includes the '#' from the opening directive and the full text of the line containing the closing directive in the skipped area. This matches up clang's behavior (we don't IRGen the code between the closing "endif" and the end of a line). This also affects the code coverage implementation. See llvm.org/PR34166 (this also happens to be rdar://problem/23224058). The old behavior (report the end of the skipped range as the end location of the 'endif' token) is preserved for indexing clients. Differential Revision: https://reviews.llvm.org/D36642 llvm-svn: 312947
2017-09-12 04:47:42 +08:00
void Preprocessor::HandleElseDirective(Token &Result, const Token &HashToken) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
++NumElse;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// #else directive in a non-skipping conditional... start skipping.
Fix the #import / #include_next "extra tokens at end of #foo directive" Warning to properly report that it is an import/include_next instead of claiming it is a #include. llvm-svn: 69023
2009-04-14 13:07:49 +08:00
CheckEndOfDirective("else");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
PPConditionalInfo CI;
Convert the lexer and start converting the PP over to using canonical Diag methods. llvm-svn: 59511
2008-11-18 15:59:24 +08:00
if (CurPPLexer->popConditionalLevel(CI)) {
Diag(Result, diag::pp_err_else_without_if);
return;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// If this is a top-level #else, inform the MIOpt.
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
if (CurPPLexer->getConditionalStackDepth() == 0)
CurPPLexer->MIOpt.EnterTopLevelConditional();
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// If this is a #else with a #else before it, report the error.
if (CI.FoundElse) Diag(Result, diag::pp_err_else_after_else);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[preprocessor] Enhance the preprocessor callbacks: -Add location parameter for the directives callbacks -Skip callbacks if the directive is inside a skipped range. -Make sure the directive callbacks are invoked in source order. llvm-svn: 152017
2012-03-05 13:48:09 +08:00
if (Callbacks)
Callbacks->Else(Result.getLocation(), CI.IfLoc);
[preprocessor] Fix assertion hit when 'SingleFileParseMode' option is enabled and #if with an undefined identifier and without #else 'HandleEndifDirective' asserts that 'WasSkipping' is false, so switch to using 'FoundNonSkip' as the hint for 'SingleFileParseMode' to keep going with parsing. llvm-svn: 305940
2017-06-22 02:52:44 +08:00
if (PPOpts->SingleFileParseMode && !CI.FoundNonSkip) {
[preprocessor] When preprocessor option 'SingleFileParseMode' is enabled, parse all directive blocks if the condition uses undefined macros This is useful for being able to parse the preprocessor directive blocks even if the header, that defined the macro that is checked, hasn't been included. Differential Revision: https://reviews.llvm.org/D34263 llvm-svn: 305797
2017-06-20 22:36:58 +08:00
// In 'single-file-parse mode' undefined identifiers trigger parsing of all
// the directive blocks.
CurPPLexer->pushConditionalLevel(CI.IfLoc, /*wasskip*/false,
[preprocessor] Fix assertion hit when 'SingleFileParseMode' option is enabled and #if with an undefined identifier and without #else 'HandleEndifDirective' asserts that 'WasSkipping' is false, so switch to using 'FoundNonSkip' as the hint for 'SingleFileParseMode' to keep going with parsing. llvm-svn: 305940
2017-06-22 02:52:44 +08:00
/*foundnonskip*/false, /*foundelse*/true);
[preprocessor] When preprocessor option 'SingleFileParseMode' is enabled, parse all directive blocks if the condition uses undefined macros This is useful for being able to parse the preprocessor directive blocks even if the header, that defined the macro that is checked, hasn't been included. Differential Revision: https://reviews.llvm.org/D34263 llvm-svn: 305797
2017-06-20 22:36:58 +08:00
return;
}
Add PPCallbacks for #if/#ifdef/etc. The callback info for #if/#elif is not great -- ideally it would give us a list of tokens in the #if, or even better, a little parse tree. But that's a lot more work. Instead, clients can retokenize using Lexer::LexFromRawLexer(). Reviewed by nlewycky. llvm-svn: 118318
2010-11-06 09:19:03 +08:00
// Finally, skip the rest of the contents of this block.
[preamble] Also record the "skipping" state of the preprocessor When a preamble ends in a conditional preprocessor block that is being skipped, the preprocessor needs to continue skipping that block when the preamble is used. This fixes PR34570. llvm-svn: 317308
2017-11-03 17:40:07 +08:00
SkipExcludedConditionalBlock(HashToken.getLocation(), CI.IfLoc,
/*Foundnonskip*/ true,
[Lexer] Report more precise skipped regions (PR34166) This patch teaches the preprocessor to report more precise source ranges for code that is skipped due to conditional directives. The new behavior includes the '#' from the opening directive and the full text of the line containing the closing directive in the skipped area. This matches up clang's behavior (we don't IRGen the code between the closing "endif" and the end of a line). This also affects the code coverage implementation. See llvm.org/PR34166 (this also happens to be rdar://problem/23224058). The old behavior (report the end of the skipped range as the end location of the 'endif' token) is preserved for indexing clients. Differential Revision: https://reviews.llvm.org/D36642 llvm-svn: 312947
2017-09-12 04:47:42 +08:00
/*FoundElse*/ true, Result.getLocation());
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
Documentation cleanup: * Add \brief summaries; * Escape # characters in Doxygen comments; * Add \code...\endcode markup for code examples; * Add \verbatim...\endverbatim markup for grammar productions. llvm-svn: 158976
2012-06-22 13:46:07 +08:00
/// HandleElifDirective - Implements the \#elif directive.
Add PPCallbacks for #if/#ifdef/etc. The callback info for #if/#elif is not great -- ideally it would give us a list of tokens in the #if, or even better, a little parse tree. But that's a lot more work. Instead, clients can retokenize using Lexer::LexFromRawLexer(). Reviewed by nlewycky. llvm-svn: 118318
2010-11-06 09:19:03 +08:00
///
[Lexer] Report more precise skipped regions (PR34166) This patch teaches the preprocessor to report more precise source ranges for code that is skipped due to conditional directives. The new behavior includes the '#' from the opening directive and the full text of the line containing the closing directive in the skipped area. This matches up clang's behavior (we don't IRGen the code between the closing "endif" and the end of a line). This also affects the code coverage implementation. See llvm.org/PR34166 (this also happens to be rdar://problem/23224058). The old behavior (report the end of the skipped range as the end location of the 'endif' token) is preserved for indexing clients. Differential Revision: https://reviews.llvm.org/D36642 llvm-svn: 312947
2017-09-12 04:47:42 +08:00
void Preprocessor::HandleElifDirective(Token &ElifToken,
const Token &HashToken) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
++NumElse;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Remove random windows line endings that snuck into the middle of this code. llvm-svn: 351633
2019-01-19 14:36:00 +08:00
// #elif directive in a non-skipping conditional... start skipping.
// We don't care what the condition is, because we will always skip it (since
// the block immediately before it was included).
SourceRange ConditionRange = DiscardUntilEndOfDirective();
PPConditionalInfo CI;
if (CurPPLexer->popConditionalLevel(CI)) {
Convert the lexer and start converting the PP over to using canonical Diag methods. llvm-svn: 59511
2008-11-18 15:59:24 +08:00
Diag(ElifToken, diag::pp_err_elif_without_if);
return;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// If this is a top-level #elif, inform the MIOpt.
Change a bunch of uses of 'CurLexer->' to 'CurPPLexer->', which should be the alias for the current PreprocessorLexer. No functionality change. Performance testing shows this results in no performance degradation when preprocessing Cocoa.h. llvm-svn: 59474
2008-11-18 08:34:22 +08:00
if (CurPPLexer->getConditionalStackDepth() == 0)
CurPPLexer->MIOpt.EnterTopLevelConditional();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// If this is a #elif with a #else before it, report the error.
Remove random windows line endings that snuck into the middle of this code. llvm-svn: 351633
2019-01-19 14:36:00 +08:00
if (CI.FoundElse) Diag(ElifToken, diag::pp_err_elif_after_else);
if (Callbacks)
Callbacks->Elif(ElifToken.getLocation(), ConditionRange,
PPCallbacks::CVK_NotEvaluated, CI.IfLoc);
if (PPOpts->SingleFileParseMode && !CI.FoundNonSkip) {
[preprocessor] When preprocessor option 'SingleFileParseMode' is enabled, parse all directive blocks if the condition uses undefined macros This is useful for being able to parse the preprocessor directive blocks even if the header, that defined the macro that is checked, hasn't been included. Differential Revision: https://reviews.llvm.org/D34263 llvm-svn: 305797
2017-06-20 22:36:58 +08:00
// In 'single-file-parse mode' undefined identifiers trigger parsing of all
// the directive blocks.
[preprocessor] Fix assertion hit when 'SingleFileParseMode' option is enabled and #if with an undefined identifier and without #else 'HandleEndifDirective' asserts that 'WasSkipping' is false, so switch to using 'FoundNonSkip' as the hint for 'SingleFileParseMode' to keep going with parsing. llvm-svn: 305940
2017-06-22 02:52:44 +08:00
CurPPLexer->pushConditionalLevel(ElifToken.getLocation(), /*wasskip*/false,
[preprocessor] When preprocessor option 'SingleFileParseMode' is enabled, parse all directive blocks if the condition uses undefined macros This is useful for being able to parse the preprocessor directive blocks even if the header, that defined the macro that is checked, hasn't been included. Differential Revision: https://reviews.llvm.org/D34263 llvm-svn: 305797
2017-06-20 22:36:58 +08:00
/*foundnonskip*/false, /*foundelse*/false);
return;
}
Add PPCallbacks for #if/#ifdef/etc. The callback info for #if/#elif is not great -- ideally it would give us a list of tokens in the #if, or even better, a little parse tree. But that's a lot more work. Instead, clients can retokenize using Lexer::LexFromRawLexer(). Reviewed by nlewycky. llvm-svn: 118318
2010-11-06 09:19:03 +08:00
// Finally, skip the rest of the contents of this block.
[preamble] Also record the "skipping" state of the preprocessor When a preamble ends in a conditional preprocessor block that is being skipped, the preprocessor needs to continue skipping that block when the preamble is used. This fixes PR34570. llvm-svn: 317308
2017-11-03 17:40:07 +08:00
SkipExcludedConditionalBlock(
HashToken.getLocation(), CI.IfLoc, /*Foundnonskip*/ true,
/*FoundElse*/ CI.FoundElse, ElifToken.getLocation());
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}