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

2791 lines
103 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
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
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
/// \brief Implements # directive processing for the Preprocessor.
///
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"
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/PTHLexer.h"
#include "clang/Lex/Token.h"
#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.
//===----------------------------------------------------------------------===//
Implement #pragma push_macro, patch by Francois Pichet! llvm-svn: 111234
2010-08-17 23:55:45 +08:00
MacroInfo *Preprocessor::AllocateMacroInfo() {
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
MacroInfoChain *MIChain = BP.Allocate<MacroInfoChain>();
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
MIChain->Next = MIChainHead;
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
}
MacroInfo *Preprocessor::AllocateMacroInfo(SourceLocation L) {
MacroInfo *MI = AllocateMacroInfo();
Preprocessor: Allocate MacroInfo objects using a BumpPtrAllocator instead using new/delete. This speeds up -Eonly on Cocoa.h using the regular lexer by 1.8% and the PTHLexer by 3%. llvm-svn: 61042
2008-12-16 03:56:42 +08:00
new (MI) MacroInfo(L);
return MI;
}
[modules] When a MacroInfo object is deserialized, allocate and store its submodule ID. llvm-svn: 177760
2013-03-23 05:12:51 +08:00
MacroInfo *Preprocessor::AllocateDeserializedMacroInfo(SourceLocation L,
unsigned SubModuleID) {
[C++11] Switch from LLVM_STATIC_ASSERT to static_assert now that we require host toolchains which support this. llvm-svn: 202640
2014-03-02 21:02:01 +08:00
static_assert(llvm::AlignOf<MacroInfo>::Alignment >= sizeof(SubModuleID),
"alignment for MacroInfo is less than the ID");
[PCH] Fix memory leak related to deserialized MacroInfo objects. Deserialized MacroInfos were not destroyed and if their SmallVector did heap allocation, it was leaked. rdar://13768967 llvm-svn: 180771
2013-04-30 13:05:35 +08:00
DeserializedMacroInfoChain *MIChain =
BP.Allocate<DeserializedMacroInfoChain>();
MIChain->Next = DeserialMIChainHead;
DeserialMIChainHead = MIChain;
MacroInfo *MI = &MIChain->MI;
[modules] When a MacroInfo object is deserialized, allocate and store its submodule ID. llvm-svn: 177760
2013-03-23 05:12:51 +08:00
new (MI) MacroInfo(L);
MI->FromASTFile = true;
MI->setOwningModuleID(SubModuleID);
return MI;
}
[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
}
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
/// \brief Read and discard all tokens remaining on the current line until
/// the tok::eod token is found.
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
void Preprocessor::DiscardUntilEndOfDirective() {
Token Tmp;
do {
LexUnexpandedToken(Tmp);
Reimplement __pragma support using a TokenLexer llvm-svn: 126221
2011-02-22 21:49:06 +08:00
assert(Tmp.isNot(tok::eof) && "EOF seen while discarding directive tokens");
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 (Tmp.isNot(tok::eod));
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +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
/// \brief Enumerates possible cases of #define/#undef a reserved identifier.
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
};
/// \brief Checks if the specified identifier is reserved in the specified
/// 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;
}
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();
[C++11] Use 'nullptr'. Lex edition. llvm-svn: 209083
2014-05-18 07:10:59 +08:00
if (!II) {
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;
std::string Spelling = getSpelling(MacroNameTok, &Invalid);
if (Invalid)
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_pp_macro_not_identifier);
Preprocessor: don't exit early in CheckMacroName() The checks below can hypothetically apply to converted operator name identifiers. In practice there are no builtin macros etc. with those names so there's no behavioural change to test. llvm-svn: 209962
2014-05-31 11:38:08 +08:00
II = getIdentifierInfo(Spelling);
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
Preprocessor: don't exit early in CheckMacroName() The checks below can hypothetically apply to converted operator name identifiers. In practice there are no builtin macros etc. with those names so there's no behavioural change to test. llvm-svn: 209962
2014-05-31 11:38:08 +08:00
if (!II->isCPlusPlusOperatorKeyword())
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
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: 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
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: don't exit early in CheckMacroName() The checks below can hypothetically apply to converted operator name identifiers. In practice there are no builtin macros etc. with those names so there's no behavioural change to test. llvm-svn: 209962
2014-05-31 11:38:08 +08:00
MacroNameTok.setIdentifierInfo(II);
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) &&
(strcmp(SourceMgr.getBufferName(MacroNameLoc), "<built-in>") != 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
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;
}
/// \brief Lex and validate a macro name, which occurs after a
/// \#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
}
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
/// \brief Ensure that the next token is a tok::eod token.
///
/// 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.
void 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
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 (Tmp.isNot(tok::eod)) {
Offer a fixit hint for our warning about tokens at the end of a directive: t.c:3:8: warning: extra tokens at end of #endif directive #endif foo ^ // Don't do this in strict-C89 mode because bcpl comments aren't valid there, and it is too much trouble to analyze whether C block comments are safe. llvm-svn: 69024
2009-04-14 13:15:20 +08:00
// Add a fixit in GNU/C99/C++ mode. Don't offer a fixit for strict-C89,
Make TokenLexer capable of storing preprocessor directive tokens llvm-svn: 126220
2011-02-22 21:49:00 +08:00
// 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.
Reinstate my CodeModificationHint -> FixItHint renaming patch, without the C-only "optimization". llvm-svn: 100022
2010-04-01 01:46:05 +08:00
FixItHint Hint;
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.GNUMode || LangOpts.C99 || LangOpts.CPlusPlus) &&
Make TokenLexer capable of storing preprocessor directive tokens llvm-svn: 126220
2011-02-22 21:49:00 +08:00
!CurTokenLexer)
Reinstate my CodeModificationHint -> FixItHint renaming patch, without the C-only "optimization". llvm-svn: 100022
2010-04-01 01:46:05 +08:00
Hint = FixItHint::CreateInsertion(Tmp.getLocation(),"//");
Diag(Tmp, diag::ext_pp_extra_tokens_at_eol) << DirType << Hint;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
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
/// 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.
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
void Preprocessor::SkipExcludedConditionalBlock(SourceLocation IfTokenLoc,
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
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(IfTokenLoc, /*isSkipping*/false,
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
FoundNonSkipPortion, FoundElse);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Added PTH optimization to not process entire blocks of tokens that appear in skipped preprocessor blocks. This improves PTH speed by 6%. The code for this optimization itself is not very optimized, and will get cleaned up. llvm-svn: 60956
2008-12-13 02:34:08 +08:00
if (CurPTHLexer) {
PTHSkipExcludedConditionalBlock();
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
// 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)) {
// Emit errors for each unterminated conditional on the stack, including
// the current one.
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
while (!CurPPLexer->ConditionalStack.empty()) {
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
if (CurLexer->getFileLoc() != CodeCompletionFileLoc)
Don't emit end-of-file diagnostics like "unterminated conditional" or "unterminated string" when we're performing code completion. llvm-svn: 110933
2010-08-13 01:04:55 +08:00
Diag(CurPPLexer->ConditionalStack.back().IfLoc,
diag::err_pp_unterminated_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
CurPPLexer->ConditionalStack.pop_back();
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
// Just return and let the caller lex after this #include.
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);
Convert to StringRef, avoid a memcpy in the common case. llvm-svn: 92357
2009-12-31 21:32:38 +08:00
unsigned 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.
if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) {
DiscardUntilEndOfDirective();
} else {
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
const SourceLocation CondBegin = CurPPLexer->getSourceLocation();
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Restore the value of LexingRawMode so that identifiers are
// looked up, etc, inside the #elif expression.
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(CurPPLexer->LexingRawMode && "We have to be skipping here!");
CurPPLexer->LexingRawMode = false;
[C++11] Use 'nullptr'. Lex edition. llvm-svn: 209083
2014-05-18 07:10:59 +08:00
IdentifierInfo *IfNDefMacro = nullptr;
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
const bool CondValue = EvaluateDirectiveExpression(IfNDefMacro);
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;
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 (Callbacks) {
const SourceLocation CondEnd = CurPPLexer->getSourceLocation();
[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->Elif(Tok.getLocation(),
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
SourceRange(CondBegin, CondEnd),
Changed ConditionValue argument to PPCallbacks If and Elif callbacks to be a 3-state enum. llvm-svn: 196648
2013-12-07 16:41:15 +08:00
(CondValue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False), CondInfo.IfLoc);
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 condition is true, enter it!
if (CondValue) {
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
if (Callbacks) {
SourceLocation BeginLoc = ElseLoc.isValid() ? ElseLoc : IfTokenLoc;
Callbacks->SourceRangeSkipped(SourceRange(BeginLoc, Tok.getLocation()));
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
}
Added PTH optimization to not process entire blocks of tokens that appear in skipped preprocessor blocks. This improves PTH speed by 6%. The code for this optimization itself is not very optimized, and will get cleaned up. llvm-svn: 60956
2008-12-13 02:34:08 +08:00
void Preprocessor::PTHSkipExcludedConditionalBlock() {
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) {
Added PTH optimization to not process entire blocks of tokens that appear in skipped preprocessor blocks. This improves PTH speed by 6%. The code for this optimization itself is not very optimized, and will get cleaned up. llvm-svn: 60956
2008-12-13 02:34:08 +08:00
assert(CurPTHLexer);
assert(CurPTHLexer->LexingRawMode == false);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Added PTH optimization to not process entire blocks of tokens that appear in skipped preprocessor blocks. This improves PTH speed by 6%. The code for this optimization itself is not very optimized, and will get cleaned up. llvm-svn: 60956
2008-12-13 02:34:08 +08:00
// Skip to the next '#else', '#elif', or #endif.
if (CurPTHLexer->SkipBlock()) {
// We have reached an #endif. Both the '#' and 'endif' tokens
// have been consumed by the PTHLexer. Just pop off the condition level.
PPConditionalInfo CondInfo;
bool InCond = CurPTHLexer->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.
Added PTH optimization to not process entire blocks of tokens that appear in skipped preprocessor blocks. This improves PTH speed by 6%. The code for this optimization itself is not very optimized, and will get cleaned up. llvm-svn: 60956
2008-12-13 02:34:08 +08:00
assert(!InCond && "Can't be skipping if not in a conditional!");
break;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Added PTH optimization to not process entire blocks of tokens that appear in skipped preprocessor blocks. This improves PTH speed by 6%. The code for this optimization itself is not very optimized, and will get cleaned up. llvm-svn: 60956
2008-12-13 02:34:08 +08:00
// We have reached a '#else' or '#elif'. Lex the next token to get
// the directive flavor.
Token Tok;
LexUnexpandedToken(Tok);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Added PTH optimization to not process entire blocks of tokens that appear in skipped preprocessor blocks. This improves PTH speed by 6%. The code for this optimization itself is not very optimized, and will get cleaned up. llvm-svn: 60956
2008-12-13 02:34:08 +08:00
// We can actually look up the IdentifierInfo here since we aren't in
// raw mode.
tok::PPKeywordKind K = Tok.getIdentifierInfo()->getPPKeywordID();
if (K == tok::pp_else) {
// #else: Enter the else condition. We aren't in a nested condition
// since we skip those. We're always in the one matching the last
// blocked we skipped.
PPConditionalInfo &CondInfo = CurPTHLexer->peekConditionalLevel();
// 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
Added PTH optimization to not process entire blocks of tokens that appear in skipped preprocessor blocks. This improves PTH speed by 6%. The code for this optimization itself is not very optimized, and will get cleaned up. llvm-svn: 60956
2008-12-13 02:34:08 +08:00
// If the #if block wasn't entered then enter the #else block now.
if (!CondInfo.FoundNonSkip) {
CondInfo.FoundNonSkip = true;
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
// Scan until the eod token.
PTH: - Embed 'eom' tokens in PTH file. - Use embedded 'eom' tokens to not lazily generate them in the PTHLexer. This means that PTHLexer can always advance to the next token after reading a token (instead of buffering tokens using a copy). - Moved logic of 'ReadToken' into Lex. GetToken & ReadToken no longer exist. - These changes result in a 3.3% speedup (-Eonly) on Cocoa.h. - The code is a little gross. Many cleanups are possible and should be done. llvm-svn: 61360
2008-12-23 09:30:52 +08:00
CurPTHLexer->ParsingPreprocessorDirective = true;
Fix assertion failure in PTH when tokens followed a closing #endif. - Ted, please check. - Missing test case because PTH won't reliably cache the tokens in a test case. *cough* llvm-svn: 68966
2009-04-14 01:57:49 +08:00
DiscardUntilEndOfDirective();
PTH: - Embed 'eom' tokens in PTH file. - Use embedded 'eom' tokens to not lazily generate them in the PTHLexer. This means that PTHLexer can always advance to the next token after reading a token (instead of buffering tokens using a copy). - Moved logic of 'ReadToken' into Lex. GetToken & ReadToken no longer exist. - These changes result in a 3.3% speedup (-Eonly) on Cocoa.h. - The code is a little gross. Many cleanups are possible and should be done. llvm-svn: 61360
2008-12-23 09:30:52 +08:00
CurPTHLexer->ParsingPreprocessorDirective = false;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Added PTH optimization to not process entire blocks of tokens that appear in skipped preprocessor blocks. This improves PTH speed by 6%. The code for this optimization itself is not very optimized, and will get cleaned up. llvm-svn: 60956
2008-12-13 02:34:08 +08:00
break;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Added PTH optimization to not process entire blocks of tokens that appear in skipped preprocessor blocks. This improves PTH speed by 6%. The code for this optimization itself is not very optimized, and will get cleaned up. llvm-svn: 60956
2008-12-13 02:34:08 +08:00
// Otherwise skip this block.
continue;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Added PTH optimization to not process entire blocks of tokens that appear in skipped preprocessor blocks. This improves PTH speed by 6%. The code for this optimization itself is not very optimized, and will get cleaned up. llvm-svn: 60956
2008-12-13 02:34:08 +08:00
assert(K == tok::pp_elif);
PPConditionalInfo &CondInfo = CurPTHLexer->peekConditionalLevel();
// If this is a #elif with a #else before it, report the error.
if (CondInfo.FoundElse)
Diag(Tok, diag::pp_err_elif_after_else);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Added PTH optimization to not process entire blocks of tokens that appear in skipped preprocessor blocks. This improves PTH speed by 6%. The code for this optimization itself is not very optimized, and will get cleaned up. llvm-svn: 60956
2008-12-13 02:34:08 +08:00
// If this is in a skipping block or if we're already handled this #if
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// block, don't bother parsing the condition. We just skip this block.
Added PTH optimization to not process entire blocks of tokens that appear in skipped preprocessor blocks. This improves PTH speed by 6%. The code for this optimization itself is not very optimized, and will get cleaned up. llvm-svn: 60956
2008-12-13 02:34:08 +08:00
if (CondInfo.FoundNonSkip)
continue;
// Evaluate the condition of the #elif.
[C++11] Use 'nullptr'. Lex edition. llvm-svn: 209083
2014-05-18 07:10:59 +08:00
IdentifierInfo *IfNDefMacro = nullptr;
Added PTH optimization to not process entire blocks of tokens that appear in skipped preprocessor blocks. This improves PTH speed by 6%. The code for this optimization itself is not very optimized, and will get cleaned up. llvm-svn: 60956
2008-12-13 02:34:08 +08:00
CurPTHLexer->ParsingPreprocessorDirective = true;
bool ShouldEnter = EvaluateDirectiveExpression(IfNDefMacro);
CurPTHLexer->ParsingPreprocessorDirective = false;
// If this condition is true, enter it!
if (ShouldEnter) {
CondInfo.FoundNonSkip = true;
break;
}
// Otherwise, skip this block and go to the next one.
}
}
[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] 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::getModuleContainingLocation(SourceLocation Loc) {
return HeaderInfo.getModuleMap().inferModuleFromLocation(
FullSourceLoc(Loc, SourceMgr));
}
[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,
SourceLocation Loc) {
// If we have a module import syntax, we shouldn't include a header to
// make a particular module visible.
if (getLangOpts().ObjC2)
return nullptr;
// Figure out which module we'd want to import.
Module *M = getModuleContainingLocation(Loc);
if (!M)
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);
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(
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
SourceLocation FilenameLoc,
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 Filename,
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
bool isAngled,
const DirectoryLookup *FromDir,
[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 *FromFile,
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 DirectoryLookup *&CurDir,
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
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,
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,
Allow preprocessor callbacks to recover from a "file not found" error, from Jason Haslam! llvm-svn: 145012
2011-11-21 01:46:46 +08:00
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) {
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
for (unsigned i = 0, e = IncludeMacroStack.size(); i != e; ++i) {
IncludeStackInfo &ISEntry = IncludeMacroStack[e - i - 1];
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,
SuggestedModule, 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,
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
RelativePath, RequestingModule, SuggestedModule, 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
move PP::LookupFile from PPLexerChange -> PPDirectives.cpp llvm-svn: 48082
2008-03-09 12:17:44 +08:00
for (unsigned i = 0, e = IncludeMacroStack.size(); i != e; ++i) {
IncludeStackInfo &ISEntry = IncludeMacroStack[e-i-1];
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;
};
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();
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);
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:
return HandleIfDirective(Result, ReadAnyTokensBeforeDirective);
case tok::pp_ifdef:
return HandleIfdefDirective(Result, false, true/*not valid for miopt*/);
case tok::pp_ifndef:
return HandleIfdefDirective(Result, true, ReadAnyTokensBeforeDirective);
case tok::pp_elif:
return HandleElifDirective(Result);
case tok::pp_else:
return HandleElseDirective(Result);
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:
return HandleUndefDirective(Result);
// C99 6.10.4 - Line Control.
case tok::pp_line:
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
return HandleLineDirective(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.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)
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 HandleMacroPrivateDirective(Result);
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;
}
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
/// \brief Handle a \#line directive: C99 6.10.4.
///
/// 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
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
void Preprocessor::HandleLineDirective(Token &Tok) {
// 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))
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
; // ok
else if (StrTok.isNot(tok::string_literal)) {
Diag(StrTok, diag::err_pp_line_invalid_filename);
User-defined literals: reject string and character UDLs in all places where the grammar requires a string-literal and not a user-defined-string-literal. The two constructs are still represented by the same TokenKind, in order to prevent a combinatorial explosion of different kinds of token. A flag on Token tracks whether a ud-suffix is present, in order to prevent clients from needing to look at the token's spelling. llvm-svn: 152098
2012-03-06 11:21:47 +08:00
return DiscardUntilEndOfDirective();
} else if (StrTok.hasUDSuffix()) {
Diag(StrTok, diag::err_invalid_string_udl);
return DiscardUntilEndOfDirective();
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 {
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
// Parse and validate the string, converting it into a unique ID.
Convert StringLiteralParser constructor to use ArrayRef instead of a pointer and count. llvm-svn: 211763
2014-06-26 12:58:39 +08:00
StringLiteralParser Literal(StrTok, *this);
Add support for C++0x unicode string and character literals, from Craig Topper! llvm-svn: 136210
2011-07-27 13:40:30 +08:00
assert(Literal.isAscii() && "Didn't allow wide strings in");
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
if (Literal.hadError)
return DiscardUntilEndOfDirective();
if (Literal.Pascal) {
Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
return DiscardUntilEndOfDirective();
}
Make more use of llvm::StringRef in various APIs. In particular, don't use the deprecated forms of llvm::StringMap::GetOrCreateValue(). llvm-svn: 133515
2011-06-21 23:13:30 +08:00
FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString());
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
// 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
stub out basic #line handling calls. llvm-svn: 63667
2009-02-04 05:52:55 +08:00
SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID);
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(),
PPCallbacks::RenameFile,
push line markers through -E mode. llvm-svn: 67854
2009-03-28 01:13:49 +08:00
SrcMgr::C_User);
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,
bool &IsSystemHeader, bool &IsExternCHeader,
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
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
IsSystemHeader = 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;
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
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
IsExternCHeader = 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
// 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;
bool IsSystemHeader = false, IsExternCHeader = 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;
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))
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
; // ok
else if (StrTok.isNot(tok::string_literal)) {
Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
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
return DiscardUntilEndOfDirective();
User-defined literals: reject string and character UDLs in all places where the grammar requires a string-literal and not a user-defined-string-literal. The two constructs are still represented by the same TokenKind, in order to prevent a combinatorial explosion of different kinds of token. A flag on Token tracks whether a ud-suffix is present, in order to prevent clients from needing to look at the token's spelling. llvm-svn: 152098
2012-03-06 11:21:47 +08:00
} else if (StrTok.hasUDSuffix()) {
Diag(StrTok, diag::err_invalid_string_udl);
return DiscardUntilEndOfDirective();
add parsing and constraint enforcement for GNU line marker directives. llvm-svn: 63003
2009-01-26 14:19:46 +08:00
} else {
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
// Parse and validate the string, converting it into a unique ID.
Convert StringLiteralParser constructor to use ArrayRef instead of a pointer and count. llvm-svn: 211763
2014-06-26 12:58:39 +08:00
StringLiteralParser Literal(StrTok, *this);
Add support for C++0x unicode string and character literals, from Craig Topper! llvm-svn: 136210
2011-07-27 13:40:30 +08:00
assert(Literal.isAscii() && "Didn't allow wide strings in");
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
if (Literal.hadError)
return DiscardUntilEndOfDirective();
if (Literal.Pascal) {
Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
return DiscardUntilEndOfDirective();
}
Make more use of llvm::StringRef in various APIs. In particular, don't use the deprecated forms of llvm::StringMap::GetOrCreateValue(). llvm-svn: 133515
2011-06-21 23:13:30 +08:00
FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString());
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
// If a filename was present, read any flags that are present.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (ReadLineMarkerFlags(IsFileEntry, IsFileExit,
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
IsSystemHeader, IsExternCHeader, *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.
SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID,
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
IsFileEntry, IsFileExit,
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
IsSystemHeader, IsExternCHeader);
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;
SrcMgr::CharacteristicKind FileKind = SrcMgr::C_User;
if (IsExternCHeader)
FileKind = SrcMgr::C_ExternCSystem;
else if (IsSystemHeader)
FileKind = SrcMgr::C_System;
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) {
a few minor cleanups llvm-svn: 63000
2009-01-26 13:30:54 +08:00
// PTH doesn't emit #warning or #error directives.
if (CurPTHLexer)
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
return CurPTHLexer->DiscardToEndOfLine();
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 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
// collapse multiple consequtive white space between tokens, but this isn't
// 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 tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
User-defined literals: reject string and character UDLs in all places where the grammar requires a string-literal and not a user-defined-string-literal. The two constructs are still represented by the same TokenKind, in order to prevent a combinatorial explosion of different kinds of token. A flag on Token tracks whether a ud-suffix is present, in order to prevent clients from needing to look at the token's spelling. llvm-svn: 152098
2012-03-06 11:21:47 +08:00
if (StrTok.hasUDSuffix()) {
Diag(StrTok, diag::err_invalid_string_udl);
return DiscardUntilEndOfDirective();
}
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.
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
}
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
/// \brief Handle a #public directive.
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
}
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
/// \brief Handle a #private directive.
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
void Preprocessor::HandleMacroPrivateDirective(Token &Tok) {
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
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;
}
Documentation cleanup: Doxygen-ification, typo fixes, and changing some of the duplicated documentation from .cpp files so that it's not processed by Doxygen and hence doesn't generate duplicate output. llvm-svn: 195799
2013-11-27 09:27:40 +08:00
// \brief Handle cases where the \#include name is expanded from a macro
// as multiple tokens, which need to be glued together.
//
// This occurs for code like:
// \code
// \#define FOO <a/b.h>
// \#include FOO
// \endcode
// because in this case, "<a/b.h>" is returned as 7 tokens, not one.
//
// This code concatenates and consumes tokens up to the '>' token. It returns
// false if the > was found, otherwise it returns true if it finds and consumes
// the EOD marker.
bool Preprocessor::ConcatenateIncludeName(SmallString<128> &FilenameBuffer,
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
SourceLocation &End) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Token CurTok;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Re-arranged some internal functions for coming __has_include changes. llvm-svn: 85589
2009-10-30 21:49:06 +08:00
Lex(CurTok);
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 (CurTok.isNot(tok::eod)) {
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
End = CurTok.getLocation();
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
Don't crash when code-completing after "#include <". It would be far better to actually produce a decent set of completions by checking the system include paths, but not today. Fixes PR8744. llvm-svn: 121431
2010-12-10 07:35:36 +08:00
// FIXME: Provide code completion for #includes.
if (CurTok.is(tok::code_completion)) {
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();
Don't crash when code-completing after "#include <". It would be far better to actually produce a decent set of completions by checking the system include paths, but not today. Fixes PR8744. llvm-svn: 121431
2010-12-10 07:35:36 +08:00
Lex(CurTok);
continue;
}
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Append the spelling of this token to the buffer. If there was a space
// before it, add it now.
if (CurTok.hasLeadingSpace())
FilenameBuffer.push_back(' ');
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 spelling of the token, directly into FilenameBuffer if possible.
unsigned PreAppendSize = FilenameBuffer.size();
FilenameBuffer.resize(PreAppendSize+CurTok.getLength());
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
const char *BufPtr = &FilenameBuffer[PreAppendSize];
Re-arranged some internal functions for coming __has_include changes. llvm-svn: 85589
2009-10-30 21:49:06 +08:00
unsigned ActualLen = getSpelling(CurTok, BufPtr);
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 was spelled somewhere else, copy it into FilenameBuffer.
if (BufPtr != &FilenameBuffer[PreAppendSize])
memcpy(&FilenameBuffer[PreAppendSize], BufPtr, ActualLen);
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
// Resize FilenameBuffer to the correct size.
if (CurTok.getLength() != ActualLen)
FilenameBuffer.resize(PreAppendSize+ActualLen);
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 found the '>' marker, return success.
if (CurTok.is(tok::greater))
return false;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Re-arranged some internal functions for coming __has_include changes. llvm-svn: 85589
2009-10-30 21:49:06 +08:00
Lex(CurTok);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +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 we hit the eod marker, emit an error and return true so that the caller
// knows the EOD has been read.
Re-arranged some internal functions for coming __has_include changes. llvm-svn: 85589
2009-10-30 21:49:06 +08:00
Diag(CurTok.getLocation(), diag::err_pp_expects_filename);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
return 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
/// \brief Push a token onto the token stream containing an annotation.
static void EnterAnnotationToken(Preprocessor &PP,
SourceLocation Begin, SourceLocation End,
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);
Tok[0].setLocation(Begin);
Tok[0].setAnnotationEndLoc(End);
Tok[0].setAnnotationValue(AnnotationVal);
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
PP.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
}
[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
/// \brief Produce a diagnostic informing the user that a #include or similar
/// was implicitly treated as a module import.
static void diagnoseAutoModuleImport(
Preprocessor &PP, SourceLocation HashLoc, Token &IncludeTok,
ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> Path,
SourceLocation PathEnd) {
assert(PP.getLangOpts().ObjC2 && "no import syntax available");
SmallString<128> PathString;
for (unsigned I = 0, N = Path.size(); I != N; ++I) {
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
<< FixItHint::CreateReplacement(ReplaceRange,
("@import " + PathString + ";").str());
}
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;
}
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,
[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,
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
bool isImport) {
Token FilenameTok;
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->LexIncludeFilename(FilenameTok);
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
// Reserve a buffer to get the spelling.
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> FilenameBuffer;
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 Filename;
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
SourceLocation 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
SourceLocation CharEnd; // the end of this directive, in characters
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
switch (FilenameTok.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:
// If the token kind is EOD, the error has already been diagnosed.
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
case tok::angle_string_literal:
Add an overload of Preprocessor::getSpelling which takes a SmallVector and returns a StringRef. Use it to simplify some repetitive code. llvm-svn: 97322
2010-02-27 21:44:12 +08:00
case tok::string_literal:
Filename = getSpelling(FilenameTok, FilenameBuffer);
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
End = FilenameTok.getLocation();
Make the FilenameRange of the InclusionDirective callback more accurate, preserve the macro location of the range end if the filename came from a macro. Patch by Kim Gräsman! llvm-svn: 167239
2012-11-02 01:52:58 +08:00
CharEnd = End.getLocWithOffset(FilenameTok.getLength());
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
case tok::less:
// This could be a <foo/bar.h> file coming from a macro expansion. In this
// case, glue the tokens together into FilenameBuffer and interpret those.
FilenameBuffer.push_back('<');
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
if (ConcatenateIncludeName(FilenameBuffer, End))
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
return; // Found <eod> but no ">"? Diagnostic already emitted.
Remove many superfluous SmallString::str() calls. Now that SmallString is a first-class citizen, most SmallString::str() calls are not required. This patch removes a whole bunch of them, yet there are lots more. There are two use cases where str() is really needed: 1) To use one of StringRef member functions which is not available in SmallString. 2) To convert to std::string, as StringRef implicitly converts while SmallString do not. We may wish to change this, but it may introduce ambiguity. llvm-svn: 232622
2015-03-18 18:17:07 +08:00
Filename = FilenameBuffer;
Make the FilenameRange of the InclusionDirective callback more accurate, preserve the macro location of the range end if the filename came from a macro. Patch by Kim Gräsman! llvm-svn: 167239
2012-11-02 01:52:58 +08:00
CharEnd = End.getLocWithOffset(1);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
break;
default:
Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename);
DiscardUntilEndOfDirective();
return;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
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);
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.
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 (Filename.empty()) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
DiscardUntilEndOfDirective();
return;
}
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
// Verify that there is nothing after the filename, other than EOD. Note that
Fix two problems from PR3916, and one problem I noticed while hacking on the code. llvm-svn: 69404
2009-04-18 07:56:52 +08:00
// 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.
Move clients to use IdentifierInfo::getNameStart() instead of getName() llvm-svn: 84436
2009-10-19 04:26:12 +08:00
CheckEndOfDirective(IncludeTok.getIdentifierInfo()->getNameStart(), true);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Check that we don't have infinite #include recursion.
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 (IncludeMacroStack.size() == MaxAllowedIncludeStackDepth-1) {
Diag(FilenameTok, diag::err_pp_include_too_deep);
return;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +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()) {
Diag(HashLoc, diag::err_pp_include_in_arc_cf_code_audited);
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()) {
Diag(HashLoc, diag::err_pp_include_in_assume_nonnull);
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.
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();
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
#ifndef LLVM_ON_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,
[modules] Simplify -cc1 interface for enabling implicit module maps. We used to have a flag to enable module maps, and two more flags to enable implicit module maps. This is all redundant; we don't need any flag for enabling module maps in the abstract, and we don't usually have -fno- flags for -cc1. We now have just a single flag, -fimplicit-module-maps, that enables implicitly searching the file system for module map files and loading them. The driver interface is unchanged for now. We should probably rename -fmodule-maps to -fimplicit-module-maps at some point. llvm-svn: 239789
2015-06-16 08:08:24 +08:00
&SuggestedModule);
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,
[modules] Simplify -cc1 interface for enabling implicit module maps. We used to have a flag to enable module maps, and two more flags to enable implicit module maps. This is all redundant; we don't need any flag for enabling module maps in the abstract, and we don't usually have -fno- flags for -cc1. We now have just a single flag, -fimplicit-module-maps, that enables implicitly searching the file system for module map files and loading them. The driver interface is unchanged for now. We should probably rename -fmodule-maps to -fimplicit-module-maps at some point. llvm-svn: 239789
2015-06-16 08:08:24 +08:00
&SuggestedModule, /*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,
[C++11] Use 'nullptr'. Lex edition. llvm-svn: 209083
2014-05-18 07:10:59 +08:00
Callbacks ? &RelativePath : nullptr,
[modules] Simplify -cc1 interface for enabling implicit module maps. We used to have a flag to enable module maps, and two more flags to enable implicit module maps. This is all redundant; we don't need any flag for enabling module maps in the abstract, and we don't usually have -fno- flags for -cc1. We now have just a single flag, -fimplicit-module-maps, that enables implicitly searching the file system for module map files and loading them. The driver interface is unchanged for now. We should probably rename -fmodule-maps to -fimplicit-module-maps at some point. llvm-svn: 239789
2015-06-16 08:08:24 +08:00
&SuggestedModule);
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) {
SourceRange Range(FilenameTok.getLocation(), 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
Diag(FilenameTok, diag::err_pp_file_not_found_not_fatal) <<
Filename <<
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
FixItHint::CreateReplacement(Range, "\"" + Filename.str() + "\"");
}
}
[modules] Rearrange preprocessor module visibility handling, no observable change intended. llvm-svn: 237331
2015-05-14 10:25:44 +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
if (!File)
Diag(FilenameTok, diag::err_pp_file_not_found) << Filename;
}
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
}
[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
// Should we enter the source file? Set to false if either the source file is
// known to have no effect beyond its effect on module visibility -- that is,
// if it's got an include guard that is already defined or is a modular header
// we've imported or already built.
bool ShouldEnter = true;
// 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).
if (File && SuggestedModule && getLangOpts().Modules &&
SuggestedModule.getModule()->getTopLevelModuleName() !=
[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
getLangOpts().CurrentModule) {
[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).
if (!SuggestedModule.getModule()->isAvailable() &&
[modules] Extend r266113 to cope with submodules. llvm-svn: 266116
2016-04-13 04:20:33 +08:00
!SuggestedModule.getModule()
->getTopLevelModule()
->HasIncompatibleModuleFile) {
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
Module::Requirement Requirement;
Module::UnresolvedHeaderDirective MissingHeader;
[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
Module *M = SuggestedModule.getModule();
// Identify the cause.
(void)M->isAvailable(getLangOpts(), getTargetInfo(), Requirement,
MissingHeader);
if (MissingHeader.FileNameLoc.isValid()) {
Diag(MissingHeader.FileNameLoc, diag::err_module_header_missing)
<< MissingHeader.IsUmbrella << MissingHeader.FileName;
} else {
Diag(M->DefinitionLoc, diag::err_module_unavailable)
<< M->getFullModuleName() << Requirement.second << Requirement.first;
}
Diag(FilenameTok.getLocation(),
diag::note_implicit_top_level_module_import_here)
<< M->getTopLevelModuleName();
return;
}
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.
[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 only do this in Objective-C, where we have a module-import syntax.
if (getLangOpts().ObjC2)
diagnoseAutoModuleImport(*this, HashLoc, 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
[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 (Imported)
ShouldEnter = false;
else if (Imported.isMissingExpected()) {
// 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
// actual module exists for it (because the umbrella header is
// incomplete). Treat this as a textual inclusion.
SuggestedModule = ModuleMap::KnownHeader();
} 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;
if (CurLexer) {
Result.startToken();
CurLexer->FormTokenWithChars(Result, CurLexer->BufferEnd, tok::eof);
CurLexer->cutOffLexing();
} else {
assert(CurPTHLexer && "#include but no current lexer set!");
CurPTHLexer->getEOF(Result);
}
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
}
Keep track of import dependencies between submodules within the module that's currently being built. This is important for supporting transitive dependencies ("export *" in the module map) completely. llvm-svn: 146156
2011-12-09 01:01:29 +08:00
return;
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] 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 (Callbacks) {
// Notify the callback object that we've seen an inclusion directive.
Callbacks->InclusionDirective(
HashLoc, IncludeTok,
LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled,
FilenameRange, File, SearchPath, RelativePath,
ShouldEnter ? nullptr : SuggestedModule.getModule());
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)
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
Fix the rest of rdar://6243860 hopefully. This requires changing FileIDInfo to whether the fileid is a 'extern c system header' in addition to whether it is a system header, most of this is spreading plumbing around. Once we have that, PPLexerChange bases its "file enter/exit" notifications to PPCallbacks to base the system header state on FileIDInfo instead of HeaderSearch. Finally, in Preprocessor::HandleIncludeDirective, mirror logic in GCC: the system headerness of a file being entered can be set due to the #includer or the #includee. llvm-svn: 56688
2008-09-27 04:12:23 +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.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
SrcMgr::CharacteristicKind FileCharacter =
clean up a bunch of fixme's I added, by moving DirectoryLookup::DirType into SourceManager.h llvm-svn: 56692
2008-09-27 05:18:42 +08:00
std::max(HeaderInfo.getFileDirFlavor(File),
do not use SourceManager::getFileCharacteristic(FileID), it is not safe because a #line can change the file characteristic on a per-loc basis. llvm-svn: 62501
2009-01-19 15:59:15 +08:00
SourceMgr.getFileCharacteristic(FilenameTok.getLocation()));
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
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
// FIXME: If we have a suggested module, and we've already visited this file,
// don't bother entering it again. We know it has no further effect.
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 =
File && !File->tryGetRealPathName().empty();
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 ? '<' : '"');
for (auto Component : Components) {
Path.append(Component);
// Append the separator the user used, or the close quote
Path.push_back(
Path.size() <= Filename.size() ? Filename[Path.size()-1] :
(isAngled ? '>' : '"'));
}
auto Replacement = Path.str().str();
// 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;
SourceRange Range(FilenameTok.getLocation(), CharEnd);
Diag(FilenameTok, DiagId) << Replacement <<
FixItHint::CreateReplacement(Range, Replacement);
}
}
add a PPCallback handler for a skipped #include, patch by Zhanyong Wan! llvm-svn: 101813
2010-04-20 04:44:31 +08:00
// Ask HeaderInfo if we should enter this #include file. If not, #including
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
// this file will have no effect.
[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 (ShouldEnter &&
[modules] Make the include guard optimization fire a bit more when considering re-entering a modular header. When we do the include guard check, we're in the visibility state for the file with the #include; the include guard may not be visible there, but we don't actually need it to be: if we've already parsed the submodule we're considering entering, it's always safe to skip it. llvm-svn: 241135
2015-07-01 09:51:38 +08:00
!HeaderInfo.ShouldEnterIncludeFile(*this, File, isImport,
SuggestedModule.getModule())) {
[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
ShouldEnter = false;
push some source location information down through the compiler, into ContentCache::getBuffer. This allows it to produce diagnostics on the broken #include line instead of without a location. llvm-svn: 101939
2010-04-21 04:35:58 +08:00
if (Callbacks)
add a PPCallback handler for a skipped #include, patch by Zhanyong Wan! llvm-svn: 101813
2010-04-20 04:44:31 +08:00
Callbacks->FileSkipped(*File, FilenameTok, FileCharacter);
[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
}
[modules] Rearrange preprocessor module visibility handling, no observable change intended. llvm-svn: 237331
2015-05-14 10:25:44 +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 we don't need to enter the file, stop now.
if (!ShouldEnter) {
[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.
[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
if (auto *M = SuggestedModule.getModule()) {
makeModuleVisible(M, HashLoc);
[modules] Rearrange preprocessor module visibility handling, no observable change intended. llvm-svn: 237331
2015-05-14 10:25:44 +08:00
if (IncludeTok.getIdentifierInfo()->getPPKeywordID() !=
tok::pp___include_macros)
[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
EnterAnnotationToken(*this, HashLoc, End, tok::annot_module_include, M);
[modules] Rearrange preprocessor module visibility handling, no observable change intended. llvm-svn: 237331
2015-05-14 10:25:44 +08:00
}
add a PPCallback handler for a skipped #include, patch by Zhanyong Wan! llvm-svn: 101813
2010-04-20 04:44:31 +08:00
return;
}
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.
[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
SourceLocation IncludePos = End;
// 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())
IncludePos = SourceMgr.getExpansionRange(IncludePos).second;
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()))
return;
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()) {
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
assert(!CurSubmodule && "should not have marked this as a module yet");
[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
CurSubmodule = 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.
EnterSubmodule(M, HashLoc);
[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.
EnterAnnotationToken(*this, HashLoc, End, tok::annot_module_begin, 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
}
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;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
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);
[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
} else if (CurSubmodule) {
// 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) {
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) {
Turns #import in MS Mode into an error. llvm-svn: 153009
2012-03-18 11:10:37 +08:00
if (!LangOpts.ObjC1) { // #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
}
[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, ImportTok, nullptr, nullptr, true);
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();
if (strcmp(SourceMgr.getBufferName(Loc), "<built-in>") != 0) {
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.
//===----------------------------------------------------------------------===//
/// ReadMacroDefinitionArgList - The ( starting an argument list of a macro
/// definition has just been read. Lex the rest of the arguments and the
/// closing ), updating MI with what we learn. Return true if an error occurs
/// parsing the arg list.
Fixed MacroInfo definition range for function like macros with empty body. llvm-svn: 153819
2012-04-01 04:17:27 +08:00
bool Preprocessor::ReadMacroDefinitionArgList(MacroInfo *MI, Token &Tok) {
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
SmallVector<IdentifierInfo*, 32> Arguments;
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:
// Found the end of the argument list.
detemplatify setArgumentList and some other cleanups. llvm-svn: 65187
2009-02-21 06:31:31 +08:00
if (Arguments.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) {
Diag(Tok, diag::err_pp_opencl_variadic_macros);
return true;
}
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;
}
// Add the __VA_ARGS__ identifier as an argument.
Arguments.push_back(Ident__VA_ARGS__);
MI->setIsC99Varargs();
Change MacroInfo::setArgumentList to take an ArrayRef instead of pointer and size. While there use std::copy intead of a manual loop. llvm-svn: 250987
2015-10-22 12:59:52 +08:00
MI->setArgumentList(Arguments, 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;
}
// If this is already used as an argument, it is used multiple times (e.g.
// #define X(A,A.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (std::find(Arguments.begin(), Arguments.end(), II) !=
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Arguments.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
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// Add the argument to the macro info.
Arguments.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)
Change MacroInfo::setArgumentList to take an ArrayRef instead of pointer and size. While there use std::copy intead of a manual loop. llvm-svn: 250987
2015-10-22 12:59:52 +08:00
MI->setArgumentList(Arguments, 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();
Change MacroInfo::setArgumentList to take an ArrayRef instead of pointer and size. While there use std::copy intead of a manual loop. llvm-svn: 250987
2015-10-22 12:59:52 +08:00
MI->setArgumentList(Arguments, 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
}
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
/// HandleDefineDirective - Implements \#define. This consumes the entire macro
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
/// line then lets the caller lex the next real token.
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
void Preprocessor::HandleDefineDirective(Token &DefineTok,
bool ImmediatelyAfterHeaderGuard) {
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
++NumDefined;
Token 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
bool MacroShadowsKeyword;
ReadMacroName(MacroNameTok, MU_Define, &MacroShadowsKeyword);
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;
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
// If we are supposed to keep comments in #defines, reenable comment saving
// mode.
Added conditional guard 'if (CurLexer)' when using SetCommentRetentionState(). This is because the PTHLexer will not support this method. Performance testing on preprocessing Cocoa.h shows that this results in a negligible performance difference (less than 1%). I tried making Lexer::SetCommentRetentionState() an out-of-line function (a precursor to making it a virtual function in PreprocessorLexer) and noticed a 1% decrease in speed (it is called in a hot part of the Preprocessor). llvm-svn: 59477
2008-11-18 08:43:07 +08:00
if (CurLexer) CurLexer->SetCommentRetentionState(KeepMacroComments);
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
// Create the new macro.
Preprocessor: Allocate MacroInfo objects using a BumpPtrAllocator instead using new/delete. This speeds up -Eonly on Cocoa.h using the regular lexer by 1.8% and the PTHLexer by 3%. llvm-svn: 61042
2008-12-16 03:56:42 +08:00
MacroInfo *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
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();
Fixed MacroInfo definition range for function like macros with empty body. llvm-svn: 153819
2012-04-01 04:17:27 +08:00
if (ReadMacroDefinitionArgList(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();
return;
}
Fix PR4006, incorrect handling of __VA_ARGS__ when it was the first token in a function-like macro body. This has the added bonus of moving some function-like macro specific code out of the object-like macro codepath. llvm-svn: 69530
2009-04-20 02:26:34 +08:00
// If this is a definition of a variadic C99 function-like macro, not using
// the GNU named varargs extension, enabled __VA_ARGS__.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fix PR4006, incorrect handling of __VA_ARGS__ when it was the first token in a function-like macro body. This has the added bonus of moving some function-like macro specific code out of the object-like macro codepath. llvm-svn: 69530
2009-04-20 02:26:34 +08:00
// "Poison" __VA_ARGS__, which can only appear in the expansion of a macro.
// This gets unpoisoned where it is allowed.
assert(Ident__VA_ARGS__->isPoisoned() && "__VA_ARGS__ should be poisoned!");
if (MI->isC99Varargs())
Ident__VA_ARGS__->setIsPoisoned(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
// 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.
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
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;
}
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
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
// Check for a valid macro arg identifier.
[C++11] Use 'nullptr'. Lex edition. llvm-svn: 209083
2014-05-18 07:10:59 +08:00
if (Tok.getIdentifierInfo() == 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
MI->getArgumentNum(Tok.getIdentifierInfo()) == -1) {
// 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);
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
// Disable __VA_ARGS__ again.
Ident__VA_ARGS__->setIsPoisoned(true);
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
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);
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);
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 = 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
// 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
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 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
// Disable __VA_ARGS__ again.
Ident__VA_ARGS__->setIsPoisoned(true);
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
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
MI->setDefinitionEndLoc(LastTok.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
// 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");
};
if (getLangOpts().ObjC1 &&
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
///
void Preprocessor::HandleUndefDirective(Token &UndefTok) {
++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);
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)
[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->MacroUndefined(MacroNameTok, MD);
[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
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
// If the macro is not defined, this is a noop undef, just return.
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
const MacroInfo *MI = MD.getMacroInfo();
[C++11] Use 'nullptr'. Lex edition. llvm-svn: 209083
2014-05-18 07:10:59 +08:00
if (!MI)
return;
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Don't warn for unused macro when undef'ing it, if it comes from an included file. rdar://9745065 llvm-svn: 134919
2011-07-12 04:39:47 +08:00
if (!MI->isUsed() && MI->isWarnIfUnused())
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used);
add a preprocessor callback function for #undef, patch by Alexei Svitkine! llvm-svn: 69656
2009-04-21 11:42:09 +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
if (MI->isWarnIfUnused())
WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
[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(MacroNameTok.getIdentifierInfo(),
AllocateUndefMacroDirective(MacroNameTok.getLocation()));
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
///
void Preprocessor::HandleIfdefDirective(Token &Result, bool isIfndef,
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.
SkipExcludedConditionalBlock(DirectiveTok.getLocation(),
/*Foundnonskip*/false, /*FoundElse*/false);
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?
if (!MI == isIfndef) {
// 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.
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
SkipExcludedConditionalBlock(DirectiveTok.getLocation(),
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
/*Foundnonskip*/false,
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
/*FoundElse*/false);
}
}
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,
bool ReadAnyTokensBeforeDirective) {
++NumIf;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
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
// Parse and evaluate the conditional expression.
[C++11] Use 'nullptr'. Lex edition. llvm-svn: 209083
2014-05-18 07:10:59 +08:00
IdentifierInfo *IfNDefMacro = nullptr;
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
const SourceLocation ConditionalBegin = CurPPLexer->getSourceLocation();
const bool ConditionalTrue = EvaluateDirectiveExpression(IfNDefMacro);
const SourceLocation ConditionalEnd = CurPPLexer->getSourceLocation();
fix PR2357 (#ifs didnt invalidate the multiple-inclusion optimization state) llvm-svn: 51843
2008-06-02 02:31:24 +08:00
// 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();
fix PR2357 (#ifs didnt invalidate the multiple-inclusion optimization state) llvm-svn: 51843
2008-06-02 02:31:24 +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->If(IfToken.getLocation(),
Add condition expression result to if and elif callbacks. llvm-svn: 186547
2013-07-18 08:00:36 +08:00
SourceRange(ConditionalBegin, ConditionalEnd),
Changed ConditionValue argument to PPCallbacks If and Elif callbacks to be a 3-state enum. llvm-svn: 196648
2013-12-07 16:41:15 +08:00
(ConditionalTrue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False));
[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?
if (ConditionalTrue) {
// 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.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
SkipExcludedConditionalBlock(IfToken.getLocation(), /*Foundnonskip*/false,
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
/*FoundElse*/false);
}
}
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
///
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
void Preprocessor::HandleElseDirective(Token &Result) {
++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);
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.
SkipExcludedConditionalBlock(CI.IfLoc, /*Foundnonskip*/true,
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
/*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
///
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
void Preprocessor::HandleElifDirective(Token &ElifToken) {
++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
// #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).
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
const SourceLocation ConditionalBegin = CurPPLexer->getSourceLocation();
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
DiscardUntilEndOfDirective();
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
const SourceLocation ConditionalEnd = CurPPLexer->getSourceLocation();
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(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.
if (CI.FoundElse) Diag(ElifToken, diag::pp_err_elif_after_else);
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
[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->Elif(ElifToken.getLocation(),
Add condition expression result to if and elif callbacks. llvm-svn: 186547
2013-07-18 08:00:36 +08:00
SourceRange(ConditionalBegin, ConditionalEnd),
Changed ConditionValue argument to PPCallbacks If and Elif callbacks to be a 3-state enum. llvm-svn: 196648
2013-12-07 16:41:15 +08:00
PPCallbacks::CVK_NotEvaluated, CI.IfLoc);
split preprocesor directive handling out of Preprocessor.cpp into Directives.cpp llvm-svn: 48068
2008-03-09 09:54:53 +08:00
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.
SkipExcludedConditionalBlock(CI.IfLoc, /*Foundnonskip*/true,
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
/*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
}