head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.13 netbsd-11-0-RC3:1.1.1.13 netbsd-11-0-RC2:1.1.1.13 netbsd-11-0-RC1:1.1.1.13 perseant-exfatfs-base-20250801:1.1.1.13 netbsd-11:1.1.1.13.0.10 netbsd-11-base:1.1.1.13 netbsd-10-1-RELEASE:1.1.1.13 perseant-exfatfs-base-20240630:1.1.1.13 perseant-exfatfs:1.1.1.13.0.8 perseant-exfatfs-base:1.1.1.13 netbsd-8-3-RELEASE:1.1.1.10 netbsd-9-4-RELEASE:1.1.1.12 netbsd-10-0-RELEASE:1.1.1.13 netbsd-10-0-RC6:1.1.1.13 netbsd-10-0-RC5:1.1.1.13 netbsd-10-0-RC4:1.1.1.13 netbsd-10-0-RC3:1.1.1.13 netbsd-10-0-RC2:1.1.1.13 netbsd-10-0-RC1:1.1.1.13 netbsd-10:1.1.1.13.0.6 netbsd-10-base:1.1.1.13 netbsd-9-3-RELEASE:1.1.1.12 cjep_sun2x:1.1.1.13.0.4 cjep_sun2x-base:1.1.1.13 cjep_staticlib_x-base1:1.1.1.13 netbsd-9-2-RELEASE:1.1.1.12 cjep_staticlib_x:1.1.1.13.0.2 cjep_staticlib_x-base:1.1.1.13 netbsd-9-1-RELEASE:1.1.1.12 phil-wifi-20200421:1.1.1.13 phil-wifi-20200411:1.1.1.13 phil-wifi-20200406:1.1.1.13 netbsd-8-2-RELEASE:1.1.1.10 netbsd-9-0-RELEASE:1.1.1.12 netbsd-9-0-RC2:1.1.1.12 netbsd-9-0-RC1:1.1.1.12 netbsd-9:1.1.1.12.0.2 netbsd-9-base:1.1.1.12 phil-wifi-20190609:1.1.1.12 netbsd-8-1-RELEASE:1.1.1.10 netbsd-8-1-RC1:1.1.1.10 pgoyette-compat-merge-20190127:1.1.1.11.2.1 pgoyette-compat-20190127:1.1.1.12 pgoyette-compat-20190118:1.1.1.12 pgoyette-compat-1226:1.1.1.12 pgoyette-compat-1126:1.1.1.12 pgoyette-compat-1020:1.1.1.12 pgoyette-compat-0930:1.1.1.12 pgoyette-compat-0906:1.1.1.12 netbsd-7-2-RELEASE:1.1.1.6.2.1 pgoyette-compat-0728:1.1.1.12 clang-337282:1.1.1.12 netbsd-8-0-RELEASE:1.1.1.10 phil-wifi:1.1.1.11.0.4 phil-wifi-base:1.1.1.11 pgoyette-compat-0625:1.1.1.11 netbsd-8-0-RC2:1.1.1.10 pgoyette-compat-0521:1.1.1.11 pgoyette-compat-0502:1.1.1.11 pgoyette-compat-0422:1.1.1.11 netbsd-8-0-RC1:1.1.1.10 pgoyette-compat-0415:1.1.1.11 pgoyette-compat-0407:1.1.1.11 pgoyette-compat-0330:1.1.1.11 pgoyette-compat-0322:1.1.1.11 pgoyette-compat-0315:1.1.1.11 netbsd-7-1-2-RELEASE:1.1.1.6.2.1 pgoyette-compat:1.1.1.11.0.2 pgoyette-compat-base:1.1.1.11 netbsd-7-1-1-RELEASE:1.1.1.6.2.1 clang-319952:1.1.1.11 matt-nb8-mediatek:1.1.1.10.0.8 matt-nb8-mediatek-base:1.1.1.10 clang-309604:1.1.1.11 perseant-stdc-iso10646:1.1.1.10.0.6 perseant-stdc-iso10646-base:1.1.1.10 netbsd-8:1.1.1.10.0.4 netbsd-8-base:1.1.1.10 prg-localcount2-base3:1.1.1.10 prg-localcount2-base2:1.1.1.10 prg-localcount2-base1:1.1.1.10 prg-localcount2:1.1.1.10.0.2 prg-localcount2-base:1.1.1.10 pgoyette-localcount-20170426:1.1.1.10 bouyer-socketcan-base1:1.1.1.10 pgoyette-localcount-20170320:1.1.1.10 netbsd-7-1:1.1.1.6.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.6.2.1 netbsd-7-1-RC2:1.1.1.6.2.1 clang-294123:1.1.1.10 netbsd-7-nhusb-base-20170116:1.1.1.6.2.1 bouyer-socketcan:1.1.1.9.0.2 bouyer-socketcan-base:1.1.1.9 clang-291444:1.1.1.9 pgoyette-localcount-20170107:1.1.1.8 netbsd-7-1-RC1:1.1.1.6.2.1 pgoyette-localcount-20161104:1.1.1.8 netbsd-7-0-2-RELEASE:1.1.1.6.2.1 localcount-20160914:1.1.1.8 netbsd-7-nhusb:1.1.1.6.2.1.0.4 netbsd-7-nhusb-base:1.1.1.6.2.1 clang-280599:1.1.1.8 pgoyette-localcount-20160806:1.1.1.8 pgoyette-localcount-20160726:1.1.1.8 pgoyette-localcount:1.1.1.8.0.2 pgoyette-localcount-base:1.1.1.8 netbsd-7-0-1-RELEASE:1.1.1.6.2.1 clang-261930:1.1.1.8 netbsd-7-0:1.1.1.6.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.6.2.1 netbsd-7-0-RC3:1.1.1.6.2.1 netbsd-7-0-RC2:1.1.1.6.2.1 netbsd-7-0-RC1:1.1.1.6.2.1 clang-237755:1.1.1.7 clang-232565:1.1.1.7 clang-227398:1.1.1.7 tls-maxphys-base:1.1.1.6 tls-maxphys:1.1.1.6.0.4 netbsd-7:1.1.1.6.0.2 netbsd-7-base:1.1.1.6 clang-215315:1.1.1.6 clang-209886:1.1.1.5 yamt-pagecache:1.1.1.4.0.4 yamt-pagecache-base9:1.1.1.4 tls-earlyentropy:1.1.1.4.0.2 tls-earlyentropy-base:1.1.1.5 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.4 riastradh-drm2-base3:1.1.1.4 clang-202566:1.1.1.4 clang-201163:1.1.1.4 clang-199312:1.1.1.3 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.52; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.52; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.39.24; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.01.15.21.26.24; author joerg; state Exp; branches; next 1.1.1.4; commitid NQXlzzA0SPkc5glx; 1.1.1.4 date 2014.02.14.20.07.23; author joerg; state Exp; branches 1.1.1.4.2.1 1.1.1.4.4.1; next 1.1.1.5; commitid annVkZ1sc17rF6px; 1.1.1.5 date 2014.05.30.18.14.42; author joerg; state Exp; branches; next 1.1.1.6; commitid 8q0kdlBlCn09GACx; 1.1.1.6 date 2014.08.10.17.08.34; author joerg; state Exp; branches 1.1.1.6.2.1 1.1.1.6.4.1; next 1.1.1.7; commitid N85tXAN6Ex9VZPLx; 1.1.1.7 date 2015.01.29.19.57.30; author joerg; state Exp; branches; next 1.1.1.8; commitid mlISSizlPKvepX7y; 1.1.1.8 date 2016.02.27.22.12.04; author joerg; state Exp; branches 1.1.1.8.2.1; next 1.1.1.9; commitid tIimz3oDlh1NpBWy; 1.1.1.9 date 2017.01.11.10.35.30; author joerg; state Exp; branches 1.1.1.9.2.1; next 1.1.1.10; commitid CNnUNfII1jgNmxBz; 1.1.1.10 date 2017.02.09.17.38.29; author joerg; state Exp; branches; next 1.1.1.11; commitid UxB8JMFWM7xyMiFz; 1.1.1.11 date 2017.08.01.19.34.56; author joerg; state Exp; branches 1.1.1.11.2.1 1.1.1.11.4.1; next 1.1.1.12; commitid pMuDy65V0VicSx1A; 1.1.1.12 date 2018.07.17.18.31.05; author joerg; state Exp; branches; next 1.1.1.13; commitid wDzL46ALjrCZgwKA; 1.1.1.13 date 2019.11.13.22.19.25; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.4.2.1 date 2014.08.10.07.08.08; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.4.4.1 date 2014.02.14.20.07.23; author yamt; state dead; branches; next 1.1.1.4.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.4.4.2 date 2014.05.22.16.18.28; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.6.2.1 date 2015.06.04.20.04.29; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.6.4.1 date 2014.08.10.17.08.34; author tls; state dead; branches; next 1.1.1.6.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.6.4.2 date 2014.08.19.23.47.29; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.8.2.1 date 2017.03.20.06.52.39; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.9.2.1 date 2017.04.21.16.51.39; author bouyer; state Exp; branches; next ; commitid dUG7nkTKALCadqOz; 1.1.1.11.2.1 date 2018.07.28.04.33.21; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.11.4.1 date 2019.06.10.21.45.25; author christos; state Exp; branches; next 1.1.1.11.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.11.4.2 date 2020.04.13.07.46.36; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- PPDirectives.cpp - Directive Handling for Preprocessor -----------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// /// /// \file /// \brief Implements # directive processing for the Preprocessor. /// //===----------------------------------------------------------------------===// #include "clang/Lex/Preprocessor.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/SourceManager.h" #include "clang/Lex/CodeCompletionHandler.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/HeaderSearchOptions.h" #include "clang/Lex/LexDiagnostic.h" #include "clang/Lex/LiteralSupport.h" #include "clang/Lex/MacroInfo.h" #include "clang/Lex/ModuleLoader.h" #include "clang/Lex/Pragma.h" #include "llvm/ADT/APInt.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/SaveAndRestore.h" using namespace clang; //===----------------------------------------------------------------------===// // Utility Methods for Preprocessor Directive Handling. //===----------------------------------------------------------------------===// MacroInfo *Preprocessor::AllocateMacroInfo() { MacroInfoChain *MIChain; if (MICache) { MIChain = MICache; MICache = MICache->Next; } else { MIChain = BP.Allocate(); } MIChain->Next = MIChainHead; MIChain->Prev = 0; if (MIChainHead) MIChainHead->Prev = MIChain; MIChainHead = MIChain; return &(MIChain->MI); } MacroInfo *Preprocessor::AllocateMacroInfo(SourceLocation L) { MacroInfo *MI = AllocateMacroInfo(); new (MI) MacroInfo(L); return MI; } MacroInfo *Preprocessor::AllocateDeserializedMacroInfo(SourceLocation L, unsigned SubModuleID) { LLVM_STATIC_ASSERT(llvm::AlignOf::Alignment >= sizeof(SubModuleID), "alignment for MacroInfo is less than the ID"); DeserializedMacroInfoChain *MIChain = BP.Allocate(); MIChain->Next = DeserialMIChainHead; DeserialMIChainHead = MIChain; MacroInfo *MI = &MIChain->MI; new (MI) MacroInfo(L); MI->FromASTFile = true; MI->setOwningModuleID(SubModuleID); return MI; } DefMacroDirective * Preprocessor::AllocateDefMacroDirective(MacroInfo *MI, SourceLocation Loc, bool isImported) { DefMacroDirective *MD = BP.Allocate(); new (MD) DefMacroDirective(MI, Loc, isImported); return MD; } UndefMacroDirective * Preprocessor::AllocateUndefMacroDirective(SourceLocation UndefLoc) { UndefMacroDirective *MD = BP.Allocate(); new (MD) UndefMacroDirective(UndefLoc); return MD; } VisibilityMacroDirective * Preprocessor::AllocateVisibilityMacroDirective(SourceLocation Loc, bool isPublic) { VisibilityMacroDirective *MD = BP.Allocate(); new (MD) VisibilityMacroDirective(Loc, isPublic); return MD; } /// \brief Release the specified MacroInfo to be reused for allocating /// new MacroInfo objects. void Preprocessor::ReleaseMacroInfo(MacroInfo *MI) { MacroInfoChain *MIChain = (MacroInfoChain*) MI; if (MacroInfoChain *Prev = MIChain->Prev) { MacroInfoChain *Next = MIChain->Next; Prev->Next = Next; if (Next) Next->Prev = Prev; } else { assert(MIChainHead == MIChain); MIChainHead = MIChain->Next; MIChainHead->Prev = 0; } MIChain->Next = MICache; MICache = MIChain; MI->Destroy(); } /// \brief Read and discard all tokens remaining on the current line until /// the tok::eod token is found. void Preprocessor::DiscardUntilEndOfDirective() { Token Tmp; do { LexUnexpandedToken(Tmp); assert(Tmp.isNot(tok::eof) && "EOF seen while discarding directive tokens"); } while (Tmp.isNot(tok::eod)); } /// \brief Lex and validate a macro name, which occurs after a /// \#define or \#undef. /// /// This sets the token kind to eod and discards the rest /// of the macro line if the macro name is invalid. \p isDefineUndef is 1 if /// this is due to a a \#define, 2 if \#undef directive, 0 if it is something /// else (e.g. \#ifdef). void Preprocessor::ReadMacroName(Token &MacroNameTok, char isDefineUndef) { // Read the token, don't allow macro expansion on it. LexUnexpandedToken(MacroNameTok); if (MacroNameTok.is(tok::code_completion)) { if (CodeComplete) CodeComplete->CodeCompleteMacroName(isDefineUndef == 1); setCodeCompletionReached(); LexUnexpandedToken(MacroNameTok); } // Missing macro name? if (MacroNameTok.is(tok::eod)) { Diag(MacroNameTok, diag::err_pp_missing_macro_name); return; } IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); if (II == 0) { bool Invalid = false; std::string Spelling = getSpelling(MacroNameTok, &Invalid); if (Invalid) return; const IdentifierInfo &Info = Identifiers.get(Spelling); // Allow #defining |and| and friends in microsoft mode. if (Info.isCPlusPlusOperatorKeyword() && getLangOpts().MicrosoftMode) { MacroNameTok.setIdentifierInfo(getIdentifierInfo(Spelling)); return; } if (Info.isCPlusPlusOperatorKeyword()) // C++ 2.5p2: Alternative tokens behave the same as its primary token // except for their spellings. Diag(MacroNameTok, diag::err_pp_operator_used_as_macro_name) << Spelling; else Diag(MacroNameTok, diag::err_pp_macro_not_identifier); // Fall through on error. } else if (isDefineUndef && II->getPPKeywordID() == tok::pp_defined) { // Error if defining "defined": C99 6.10.8/4, C++ [cpp.predefined]p4. Diag(MacroNameTok, diag::err_defined_macro_name); } else if (isDefineUndef == 2 && II->hasMacroDefinition() && getMacroInfo(II)->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); return; } else { // Okay, we got a good identifier node. Return it. return; } // Invalid macro name, read and discard the rest of the line. Then set the // token kind to tok::eod. MacroNameTok.setKind(tok::eod); return DiscardUntilEndOfDirective(); } /// \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 /// true, then we consider macros that expand to zero tokens as being ok. void Preprocessor::CheckEndOfDirective(const char *DirType, bool EnableMacros) { Token Tmp; // 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); // 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); if (Tmp.isNot(tok::eod)) { // Add a fixit in GNU/C99/C++ mode. Don't offer a fixit for strict-C89, // or if this is a macro-style preprocessing directive, because it is more // trouble than it is worth to insert /**/ and check that there is no /**/ // in the range also. FixItHint Hint; if ((LangOpts.GNUMode || LangOpts.C99 || LangOpts.CPlusPlus) && !CurTokenLexer) Hint = FixItHint::CreateInsertion(Tmp.getLocation(),"//"); Diag(Tmp, diag::ext_pp_extra_tokens_at_eol) << DirType << Hint; DiscardUntilEndOfDirective(); } } /// 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 /// FoundNonSkipPortion is true, then we have already emitted code for part of /// 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. void Preprocessor::SkipExcludedConditionalBlock(SourceLocation IfTokenLoc, bool FoundNonSkipPortion, bool FoundElse, SourceLocation ElseLoc) { ++NumSkipped; assert(!CurTokenLexer && CurPPLexer && "Lexing a macro, not a file?"); CurPPLexer->pushConditionalLevel(IfTokenLoc, /*isSkipping*/false, FoundNonSkipPortion, FoundElse); if (CurPTHLexer) { PTHSkipExcludedConditionalBlock(); return; } // Enter raw mode to disable identifier lookup (and thus macro expansion), // disabling warnings, etc. CurPPLexer->LexingRawMode = true; Token Tok; while (1) { CurLexer->Lex(Tok); if (Tok.is(tok::code_completion)) { if (CodeComplete) CodeComplete->CodeCompleteInConditionalExclusion(); setCodeCompletionReached(); continue; } // 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. while (!CurPPLexer->ConditionalStack.empty()) { if (CurLexer->getFileLoc() != CodeCompletionFileLoc) Diag(CurPPLexer->ConditionalStack.back().IfLoc, diag::err_pp_unterminated_conditional); CurPPLexer->ConditionalStack.pop_back(); } // Just return and let the caller lex after this #include. break; } // If this token is not a preprocessor directive, just skip it. if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine()) continue; // 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 EOD token (this terminates the macro). CurPPLexer->ParsingPreprocessorDirective = true; if (CurLexer) CurLexer->SetKeepWhitespaceMode(false); // Read the next token, the directive flavor. LexUnexpandedToken(Tok); // If this isn't an identifier directive (e.g. is "# 1\n" or "#\n", or // something bogus), skip it. if (Tok.isNot(tok::raw_identifier)) { CurPPLexer->ParsingPreprocessorDirective = false; // Restore comment saving mode. if (CurLexer) CurLexer->resetExtendedTokenMode(); 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. const char *RawCharData = Tok.getRawIdentifierData(); char FirstChar = RawCharData[0]; if (FirstChar >= 'a' && FirstChar <= 'z' && FirstChar != 'i' && FirstChar != 'e') { CurPPLexer->ParsingPreprocessorDirective = false; // Restore comment saving mode. if (CurLexer) CurLexer->resetExtendedTokenMode(); continue; } // Get the identifier name without trigraphs or embedded newlines. Note // that we can't use Tok.getIdentifierInfo() because its lookup is disabled // when skipping. char DirectiveBuf[20]; StringRef Directive; if (!Tok.needsCleaning() && Tok.getLength() < 20) { Directive = StringRef(RawCharData, Tok.getLength()); } else { std::string DirectiveStr = getSpelling(Tok); unsigned IdLen = DirectiveStr.size(); if (IdLen >= 20) { CurPPLexer->ParsingPreprocessorDirective = false; // Restore comment saving mode. if (CurLexer) CurLexer->resetExtendedTokenMode(); continue; } memcpy(DirectiveBuf, &DirectiveStr[0], IdLen); Directive = StringRef(DirectiveBuf, IdLen); } if (Directive.startswith("if")) { StringRef Sub = Directive.substr(2); if (Sub.empty() || // "if" Sub == "def" || // "ifdef" Sub == "ndef") { // "ifndef" // We know the entire #if/#ifdef/#ifndef block will be skipped, don't // bother parsing the condition. DiscardUntilEndOfDirective(); CurPPLexer->pushConditionalLevel(Tok.getLocation(), /*wasskipping*/true, /*foundnonskip*/false, /*foundelse*/false); } } else if (Directive[0] == 'e') { StringRef Sub = Directive.substr(1); if (Sub == "ndif") { // "endif" PPConditionalInfo CondInfo; CondInfo.WasSkipping = true; // Silence bogus warning. bool InCond = CurPPLexer->popConditionalLevel(CondInfo); (void)InCond; // Silence warning in no-asserts mode. assert(!InCond && "Can't be skipping if not in a conditional!"); // If we popped the outermost skipping block, we're done skipping! if (!CondInfo.WasSkipping) { // Restore the value of LexingRawMode so that trailing comments // are handled correctly, if we've reached the outermost block. CurPPLexer->LexingRawMode = false; CheckEndOfDirective("endif"); CurPPLexer->LexingRawMode = true; if (Callbacks) Callbacks->Endif(Tok.getLocation(), CondInfo.IfLoc); break; } else { DiscardUntilEndOfDirective(); } } else if (Sub == "lse") { // "else". // #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. PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel(); // If this is a #else with a #else before it, report the error. if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_else_after_else); // Note that we've seen a #else in this conditional. CondInfo.FoundElse = true; // 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; // Restore the value of LexingRawMode so that trailing comments // are handled correctly. CurPPLexer->LexingRawMode = false; CheckEndOfDirective("else"); CurPPLexer->LexingRawMode = true; if (Callbacks) Callbacks->Else(Tok.getLocation(), CondInfo.IfLoc); break; } else { DiscardUntilEndOfDirective(); // C99 6.10p4. } } else if (Sub == "lif") { // "elif". PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel(); bool ShouldEnter; const SourceLocation ConditionalBegin = CurPPLexer->getSourceLocation(); // 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(); ShouldEnter = false; } else { // Restore the value of LexingRawMode so that identifiers are // looked up, etc, inside the #elif expression. assert(CurPPLexer->LexingRawMode && "We have to be skipping here!"); CurPPLexer->LexingRawMode = false; IdentifierInfo *IfNDefMacro = 0; ShouldEnter = EvaluateDirectiveExpression(IfNDefMacro); CurPPLexer->LexingRawMode = true; } const SourceLocation ConditionalEnd = CurPPLexer->getSourceLocation(); // If this is a #elif with a #else before it, report the error. if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_elif_after_else); // If this condition is true, enter it! if (ShouldEnter) { CondInfo.FoundNonSkip = true; if (Callbacks) Callbacks->Elif(Tok.getLocation(), SourceRange(ConditionalBegin, ConditionalEnd), ShouldEnter, CondInfo.IfLoc); break; } } } CurPPLexer->ParsingPreprocessorDirective = false; // Restore comment saving mode. if (CurLexer) CurLexer->resetExtendedTokenMode(); } // 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. CurPPLexer->LexingRawMode = false; if (Callbacks) { SourceLocation BeginLoc = ElseLoc.isValid() ? ElseLoc : IfTokenLoc; Callbacks->SourceRangeSkipped(SourceRange(BeginLoc, Tok.getLocation())); } } void Preprocessor::PTHSkipExcludedConditionalBlock() { while (1) { assert(CurPTHLexer); assert(CurPTHLexer->LexingRawMode == false); // 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); (void)InCond; // Silence warning in no-asserts mode. assert(!InCond && "Can't be skipping if not in a conditional!"); break; } // We have reached a '#else' or '#elif'. Lex the next token to get // the directive flavor. Token Tok; LexUnexpandedToken(Tok); // 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; // If the #if block wasn't entered then enter the #else block now. if (!CondInfo.FoundNonSkip) { CondInfo.FoundNonSkip = true; // Scan until the eod token. CurPTHLexer->ParsingPreprocessorDirective = true; DiscardUntilEndOfDirective(); CurPTHLexer->ParsingPreprocessorDirective = false; break; } // Otherwise skip this block. continue; } 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); // If this is in a skipping block or if we're already handled this #if // block, don't bother parsing the condition. We just skip this block. if (CondInfo.FoundNonSkip) continue; // Evaluate the condition of the #elif. IdentifierInfo *IfNDefMacro = 0; 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. continue; } } Module *Preprocessor::getModuleForLocation(SourceLocation FilenameLoc) { ModuleMap &ModMap = HeaderInfo.getModuleMap(); if (SourceMgr.isInMainFile(FilenameLoc)) { if (Module *CurMod = getCurrentModule()) return CurMod; // Compiling a module. return HeaderInfo.getModuleMap().SourceModule; // Compiling a source. } // Try to determine the module of the include directive. FileID IDOfIncl = SourceMgr.getFileID(FilenameLoc); if (const FileEntry *EntryOfIncl = SourceMgr.getFileEntryForID(IDOfIncl)) { // The include comes from a file. return ModMap.findModuleForHeader(EntryOfIncl).getModule(); } else { // The include does not come from a file, // so it is probably a module compilation. return getCurrentModule(); } } bool Preprocessor::violatesPrivateInclude( Module *RequestingModule, const FileEntry *IncFileEnt, ModuleMap::ModuleHeaderRole Role, Module *RequestedModule) { #ifndef NDEBUG // Check for consistency between the module header role // as obtained from the lookup and as obtained from the module. // This check is not cheap, so enable it only for debugging. SmallVectorImpl &PvtHdrs = RequestedModule->PrivateHeaders; SmallVectorImpl::iterator Look = std::find(PvtHdrs.begin(), PvtHdrs.end(), IncFileEnt); bool IsPrivate = Look != PvtHdrs.end(); assert((IsPrivate && Role == ModuleMap::PrivateHeader) || (!IsPrivate && Role != ModuleMap::PrivateHeader)); #endif return Role == ModuleMap::PrivateHeader && RequestedModule->getTopLevelModule() != RequestingModule; } bool Preprocessor::violatesUseDeclarations( Module *RequestingModule, Module *RequestedModule) { ModuleMap &ModMap = HeaderInfo.getModuleMap(); ModMap.resolveUses(RequestingModule, /*Complain=*/false); const SmallVectorImpl &AllowedUses = RequestingModule->DirectUses; SmallVectorImpl::const_iterator Declared = std::find(AllowedUses.begin(), AllowedUses.end(), RequestedModule); return Declared == AllowedUses.end(); } void Preprocessor::verifyModuleInclude(SourceLocation FilenameLoc, StringRef Filename, const FileEntry *IncFileEnt) { Module *RequestingModule = getModuleForLocation(FilenameLoc); if (RequestingModule) HeaderInfo.getModuleMap().resolveUses(RequestingModule, /*Complain=*/false); ModuleMap::KnownHeader RequestedModule = HeaderInfo.getModuleMap().findModuleForHeader(IncFileEnt, RequestingModule); if (RequestingModule == RequestedModule.getModule()) return; // No faults wihin a module, or between files both not in modules. if (RequestingModule != HeaderInfo.getModuleMap().SourceModule) return; // No errors for indirect modules. // This may be a bit of a problem for modules with no source files. if (RequestedModule && violatesPrivateInclude(RequestingModule, IncFileEnt, RequestedModule.getRole(), RequestedModule.getModule())) Diag(FilenameLoc, diag::error_use_of_private_header_outside_module) << Filename; // FIXME: Add support for FixIts in module map files and offer adding the // required use declaration. if (RequestingModule && getLangOpts().ModulesDeclUse && violatesUseDeclarations(RequestingModule, RequestedModule.getModule())) Diag(FilenameLoc, diag::error_undeclared_use_of_module) << Filename; } const FileEntry *Preprocessor::LookupFile( SourceLocation FilenameLoc, StringRef Filename, bool isAngled, const DirectoryLookup *FromDir, const DirectoryLookup *&CurDir, SmallVectorImpl *SearchPath, SmallVectorImpl *RelativePath, ModuleMap::KnownHeader *SuggestedModule, bool SkipCache) { // If the header lookup mechanism may be relative to the current file, pass in // info about where the current file is. const FileEntry *CurFileEnt = 0; if (!FromDir) { FileID FID = getCurrentFileLexer()->getFileID(); CurFileEnt = SourceMgr.getFileEntryForID(FID); // If there is no file entry associated with this file, it must be the // predefines 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) as if they came from the main file, this // affects file lookup etc. if (CurFileEnt == 0) { FID = SourceMgr.getMainFileID(); CurFileEnt = SourceMgr.getFileEntryForID(FID); } } // Do a standard file entry lookup. CurDir = CurDirLookup; const FileEntry *FE = HeaderInfo.LookupFile( Filename, isAngled, FromDir, CurDir, CurFileEnt, SearchPath, RelativePath, SuggestedModule, SkipCache); if (FE) { if (SuggestedModule) verifyModuleInclude(FilenameLoc, Filename, FE); return FE; } // 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. if (IsFileLexer()) { if ((CurFileEnt = SourceMgr.getFileEntryForID(CurPPLexer->getFileID()))) if ((FE = HeaderInfo.LookupSubframeworkHeader(Filename, CurFileEnt, SearchPath, RelativePath, SuggestedModule))) return FE; } for (unsigned i = 0, e = IncludeMacroStack.size(); i != e; ++i) { IncludeStackInfo &ISEntry = IncludeMacroStack[e-i-1]; if (IsFileLexer(ISEntry)) { if ((CurFileEnt = SourceMgr.getFileEntryForID(ISEntry.ThePPLexer->getFileID()))) if ((FE = HeaderInfo.LookupSubframeworkHeader( Filename, CurFileEnt, SearchPath, RelativePath, SuggestedModule))) return FE; } } // Otherwise, we really couldn't find the file. return 0; } //===----------------------------------------------------------------------===// // Preprocessor Directive Handling. //===----------------------------------------------------------------------===// class Preprocessor::ResetMacroExpansionHelper { public: ResetMacroExpansionHelper(Preprocessor *pp) : PP(pp), save(pp->DisableMacroExpansion) { if (pp->MacroExpansionInDirectivesOverride) pp->DisableMacroExpansion = false; } ~ResetMacroExpansionHelper() { PP->DisableMacroExpansion = save; } private: Preprocessor *PP; bool save; }; /// HandleDirective - This callback is invoked when the lexer sees a # token /// at the start of a line. This consumes the directive, modifies the /// 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? // 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 // EOD token (which terminates the directive). CurPPLexer->ParsingPreprocessorDirective = true; if (CurLexer) CurLexer->SetKeepWhitespaceMode(false); bool ImmediatelyAfterTopLevelIfndef = CurPPLexer->MIOpt.getImmediatelyAfterTopLevelIfndef(); CurPPLexer->MIOpt.resetImmediatelyAfterTopLevelIfndef(); ++NumDirectives; // We are about to read a token. For the multiple-include optimization FA to // work, we have to remember if we had read any tokens *before* this // pp-directive. bool ReadAnyTokensBeforeDirective =CurPPLexer->MIOpt.getHasReadAnyTokensVal(); // Save the '#' token in case we need to return it later. Token SavedHash = Result; // Read the next token, the directive flavor. This isn't expanded due to // C99 6.10.3p8. LexUnexpandedToken(Result); // C99 6.10.3p11: Is this preprocessor directive in macro invocation? e.g.: // #define A(x) #x // A(abc // #warning blah // def) // 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: Diag(Result, diag::err_embedded_include) << II->getName(); DiscardUntilEndOfDirective(); return; default: break; } } Diag(Result, diag::ext_embedded_directive); } // Temporarily enable macro expansion if set so // and reset to previous state when returning from this function. ResetMacroExpansionHelper helper(this); switch (Result.getKind()) { case tok::eod: return; // null directive. case tok::code_completion: if (CodeComplete) CodeComplete->CodeCompleteDirective( CurPPLexer->getConditionalStackDepth() > 0); setCodeCompletionReached(); return; case tok::numeric_constant: // # 7 GNU line marker directive. if (getLangOpts().AsmPreprocessor) break; // # 4 is not a preprocessor directive in .S files. return HandleDigitDirective(Result); default: IdentifierInfo *II = Result.getIdentifierInfo(); if (II == 0) break; // Not an identifier. // 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); // C99 6.10.2 - Source File Inclusion. case tok::pp_include: // Handle #include. return HandleIncludeDirective(SavedHash.getLocation(), Result); case tok::pp___include_macros: // Handle -imacros. return HandleIncludeMacrosDirective(SavedHash.getLocation(), Result); // C99 6.10.3 - Macro Replacement. case tok::pp_define: return HandleDefineDirective(Result, ImmediatelyAfterTopLevelIfndef); case tok::pp_undef: return HandleUndefDirective(Result); // C99 6.10.4 - Line Control. case tok::pp_line: return HandleLineDirective(Result); // C99 6.10.5 - Error Directive. case tok::pp_error: return HandleUserDiagnosticDirective(Result, false); // C99 6.10.6 - Pragma Directive. case tok::pp_pragma: return HandlePragmaDirective(SavedHash.getLocation(), PIK_HashPragma); // GNU Extensions. case tok::pp_import: return HandleImportDirective(SavedHash.getLocation(), Result); case tok::pp_include_next: return HandleIncludeNextDirective(SavedHash.getLocation(), Result); 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; case tok::pp___public_macro: if (getLangOpts().Modules) return HandleMacroPublicDirective(Result); break; case tok::pp___private_macro: if (getLangOpts().Modules) return HandleMacroPrivateDirective(Result); break; } break; } // 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. if (getLangOpts().AsmPreprocessor) { Token *Toks = new Token[2]; // Return the # and the token after it. Toks[0] = SavedHash; Toks[1] = Result; // 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); // 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. EnterTokenStream(Toks, 2, false, true); return; } // If we reached here, the preprocessing token is not valid! Diag(Result, diag::err_pp_invalid_directive); // Read the rest of the PP line. DiscardUntilEndOfDirective(); // Okay, we're done parsing the directive. } /// 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, unsigned DiagID, Preprocessor &PP, bool IsGNULineDirective=false) { if (DigitTok.isNot(tok::numeric_constant)) { PP.Diag(DigitTok, DiagID); if (DigitTok.isNot(tok::eod)) PP.DiscardUntilEndOfDirective(); return true; } SmallString<64> IntegerBuffer; IntegerBuffer.resize(DigitTok.getLength()); const char *DigitTokBegin = &IntegerBuffer[0]; bool Invalid = false; unsigned ActualLength = PP.getSpelling(DigitTok, DigitTokBegin, &Invalid); if (Invalid) return true; // 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) { // C++1y [lex.fcon]p1: // Optional separating single quotes in a digit-sequence are ignored if (DigitTokBegin[i] == '\'') continue; if (!isDigit(DigitTokBegin[i])) { PP.Diag(PP.AdvanceToTokenCharacter(DigitTok.getLocation(), i), diag::err_pp_line_digit_sequence) << IsGNULineDirective; PP.DiscardUntilEndOfDirective(); return true; } unsigned NextVal = Val*10+(DigitTokBegin[i]-'0'); if (NextVal < Val) { // overflow. PP.Diag(DigitTok, DiagID); PP.DiscardUntilEndOfDirective(); return true; } Val = NextVal; } if (DigitTokBegin[0] == '0' && Val) PP.Diag(DigitTok.getLocation(), diag::warn_pp_line_decimal) << IsGNULineDirective; return false; } /// \brief Handle a \#line directive: C99 6.10.4. /// /// The two acceptable forms are: /// \verbatim /// # line digit-sequence /// # line digit-sequence "s-char-sequence" /// \endverbatim 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; if (GetLineValue(DigitTok, LineNo, diag::err_pp_line_requires_integer,*this)) return; if (LineNo == 0) Diag(DigitTok, diag::ext_pp_line_zero); // Enforce C99 6.10.4p3: "The digit sequence shall not specify ... a // number greater than 2147483647". C90 requires that the line # be <= 32767. unsigned LineLimit = 32768U; if (LangOpts.C99 || LangOpts.CPlusPlus11) LineLimit = 2147483648U; if (LineNo >= LineLimit) Diag(DigitTok, diag::ext_pp_line_too_big) << LineLimit; else if (LangOpts.CPlusPlus11 && LineNo >= 32768U) Diag(DigitTok, diag::warn_cxx98_compat_pp_line_too_big); int FilenameID = -1; Token StrTok; Lex(StrTok); // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a // string followed by eod. if (StrTok.is(tok::eod)) ; // ok else if (StrTok.isNot(tok::string_literal)) { Diag(StrTok, diag::err_pp_line_invalid_filename); return DiscardUntilEndOfDirective(); } else if (StrTok.hasUDSuffix()) { Diag(StrTok, diag::err_invalid_string_udl); return DiscardUntilEndOfDirective(); } else { // Parse and validate the string, converting it into a unique ID. StringLiteralParser Literal(&StrTok, 1, *this); assert(Literal.isAscii() && "Didn't allow wide strings in"); if (Literal.hadError) return DiscardUntilEndOfDirective(); if (Literal.Pascal) { Diag(StrTok, diag::err_pp_linemarker_invalid_filename); return DiscardUntilEndOfDirective(); } FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString()); // Verify that there is nothing after the string, other than EOD. Because // of C99 6.10.4p5, macros that expand to empty tokens are ok. CheckEndOfDirective("line", true); } SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID); if (Callbacks) Callbacks->FileChanged(CurPPLexer->getSourceLocation(), PPCallbacks::RenameFile, SrcMgr::C_User); } /// 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); if (FlagTok.is(tok::eod)) return false; if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP)) return true; if (FlagVal == 1) { IsFileEntry = true; PP.Lex(FlagTok); if (FlagTok.is(tok::eod)) return false; if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP)) return true; } else if (FlagVal == 2) { IsFileExit = true; 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 = SM.getDecomposedExpansionLoc(FlagTok.getLocation()).first; PresumedLoc PLoc = SM.getPresumedLoc(FlagTok.getLocation()); if (PLoc.isInvalid()) return true; // 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() || SM.getDecomposedExpansionLoc(IncLoc).first != CurFileID) { PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_pop); PP.DiscardUntilEndOfDirective(); return true; } PP.Lex(FlagTok); if (FlagTok.is(tok::eod)) return false; 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); PP.DiscardUntilEndOfDirective(); return true; } IsSystemHeader = true; PP.Lex(FlagTok); if (FlagTok.is(tok::eod)) return false; if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP)) return true; // We must have 4 if there is yet another flag. if (FlagVal != 4) { PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag); PP.DiscardUntilEndOfDirective(); return true; } IsExternCHeader = true; PP.Lex(FlagTok); if (FlagTok.is(tok::eod)) return false; // There are no more valid flags here. PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag); PP.DiscardUntilEndOfDirective(); return true; } /// HandleDigitDirective - Handle a GNU line marker directive, whose syntax is /// one of the following forms: /// /// # 42 /// # 42 "file" ('1' | '2')? /// # 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, *this, true)) return; Token StrTok; Lex(StrTok); bool IsFileEntry = false, IsFileExit = false; bool IsSystemHeader = false, IsExternCHeader = false; int FilenameID = -1; // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a // string followed by eod. if (StrTok.is(tok::eod)) ; // ok else if (StrTok.isNot(tok::string_literal)) { Diag(StrTok, diag::err_pp_linemarker_invalid_filename); return DiscardUntilEndOfDirective(); } else if (StrTok.hasUDSuffix()) { Diag(StrTok, diag::err_invalid_string_udl); return DiscardUntilEndOfDirective(); } else { // Parse and validate the string, converting it into a unique ID. StringLiteralParser Literal(&StrTok, 1, *this); assert(Literal.isAscii() && "Didn't allow wide strings in"); if (Literal.hadError) return DiscardUntilEndOfDirective(); if (Literal.Pascal) { Diag(StrTok, diag::err_pp_linemarker_invalid_filename); return DiscardUntilEndOfDirective(); } FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString()); // If a filename was present, read any flags that are present. if (ReadLineMarkerFlags(IsFileEntry, IsFileExit, IsSystemHeader, IsExternCHeader, *this)) return; } // Create a line note with this information. SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, IsFileEntry, IsFileExit, IsSystemHeader, IsExternCHeader); // 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; Callbacks->FileChanged(CurPPLexer->getSourceLocation(), Reason, FileKind); } } /// HandleUserDiagnosticDirective - Handle a #warning or #error directive. /// void Preprocessor::HandleUserDiagnosticDirective(Token &Tok, bool isWarning) { // PTH doesn't emit #warning or #error directives. if (CurPTHLexer) return CurPTHLexer->DiscardToEndOfLine(); // 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. SmallString<128> Message; CurLexer->ReadToEndOfLine(&Message); // Find the first non-whitespace character, so that we can make the // diagnostic more succinct. StringRef Msg = Message.str().ltrim(" "); if (isWarning) Diag(Tok, diag::pp_hash_warning) << Msg; else Diag(Tok, diag::err_pp_hash_error) << Msg; } /// HandleIdentSCCSDirective - Handle a #ident/#sccs directive. /// void Preprocessor::HandleIdentSCCSDirective(Token &Tok) { // Yes, this directive is an extension. Diag(Tok, diag::ext_pp_ident_directive); // Read the string argument. Token StrTok; Lex(StrTok); // If the token kind isn't a string, it's a malformed directive. if (StrTok.isNot(tok::string_literal) && StrTok.isNot(tok::wide_string_literal)) { Diag(StrTok, diag::err_pp_malformed_ident); if (StrTok.isNot(tok::eod)) DiscardUntilEndOfDirective(); return; } if (StrTok.hasUDSuffix()) { Diag(StrTok, diag::err_invalid_string_udl); return DiscardUntilEndOfDirective(); } // Verify that there is nothing after the string, other than EOD. CheckEndOfDirective("ident"); if (Callbacks) { bool Invalid = false; std::string Str = getSpelling(StrTok, &Invalid); if (!Invalid) Callbacks->Ident(Tok.getLocation(), Str); } } /// \brief Handle a #public directive. void Preprocessor::HandleMacroPublicDirective(Token &Tok) { Token MacroNameTok; ReadMacroName(MacroNameTok, 2); // Error reading macro name? If so, diagnostic already issued. if (MacroNameTok.is(tok::eod)) return; // Check to see if this is the last token on the #__public_macro line. CheckEndOfDirective("__public_macro"); IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); // Okay, we finally have a valid identifier to undef. MacroDirective *MD = getMacroDirective(II); // If the macro is not defined, this is an error. if (MD == 0) { Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II; return; } // Note that this macro has now been exported. appendMacroDirective(II, AllocateVisibilityMacroDirective( MacroNameTok.getLocation(), /*IsPublic=*/true)); } /// \brief Handle a #private directive. void Preprocessor::HandleMacroPrivateDirective(Token &Tok) { Token MacroNameTok; ReadMacroName(MacroNameTok, 2); // Error reading macro name? If so, diagnostic already issued. if (MacroNameTok.is(tok::eod)) return; // Check to see if this is the last token on the #__private_macro line. CheckEndOfDirective("__private_macro"); IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); // Okay, we finally have a valid identifier to undef. MacroDirective *MD = getMacroDirective(II); // If the macro is not defined, this is an error. if (MD == 0) { Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II; return; } // Note that this macro has now been marked private. appendMacroDirective(II, AllocateVisibilityMacroDirective( MacroNameTok.getLocation(), /*IsPublic=*/false)); } //===----------------------------------------------------------------------===// // Preprocessor Include Directive Handling. //===----------------------------------------------------------------------===// /// GetIncludeFilenameSpelling - Turn the specified lexer token into a fully /// checked and spelled filename, e.g. as an operand of \#include. This returns /// 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, StringRef &Buffer) { // Get the text form of the filename. assert(!Buffer.empty() && "Can't have tokens with empty spellings!"); // Make sure the filename is or "x". bool isAngled; if (Buffer[0] == '<') { if (Buffer.back() != '>') { Diag(Loc, diag::err_pp_expects_filename); Buffer = StringRef(); return true; } isAngled = true; } else if (Buffer[0] == '"') { if (Buffer.back() != '"') { Diag(Loc, diag::err_pp_expects_filename); Buffer = StringRef(); return true; } isAngled = false; } else { Diag(Loc, diag::err_pp_expects_filename); Buffer = StringRef(); return true; } // Diagnose #include "" as invalid. if (Buffer.size() <= 2) { Diag(Loc, diag::err_pp_empty_filename); Buffer = StringRef(); return true; } // Skip the brackets. Buffer = Buffer.substr(1, Buffer.size()-2); return isAngled; } /// \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 /// \#include FOO /// \endcode /// because in this case, "" 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, SourceLocation &End) { Token CurTok; Lex(CurTok); while (CurTok.isNot(tok::eod)) { End = CurTok.getLocation(); // FIXME: Provide code completion for #includes. if (CurTok.is(tok::code_completion)) { setCodeCompletionReached(); Lex(CurTok); continue; } // 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(' '); // Get the spelling of the token, directly into FilenameBuffer if possible. unsigned PreAppendSize = FilenameBuffer.size(); FilenameBuffer.resize(PreAppendSize+CurTok.getLength()); const char *BufPtr = &FilenameBuffer[PreAppendSize]; unsigned ActualLen = getSpelling(CurTok, BufPtr); // If the token was spelled somewhere else, copy it into FilenameBuffer. if (BufPtr != &FilenameBuffer[PreAppendSize]) memcpy(&FilenameBuffer[PreAppendSize], BufPtr, ActualLen); // Resize FilenameBuffer to the correct size. if (CurTok.getLength() != ActualLen) FilenameBuffer.resize(PreAppendSize+ActualLen); // If we found the '>' marker, return success. if (CurTok.is(tok::greater)) return false; Lex(CurTok); } // If we hit the eod marker, emit an error and return true so that the caller // knows the EOD has been read. Diag(CurTok.getLocation(), diag::err_pp_expects_filename); return true; } /// 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 /// specifies the file to start searching from. void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc, Token &IncludeTok, const DirectoryLookup *LookupFrom, bool isImport) { Token FilenameTok; CurPPLexer->LexIncludeFilename(FilenameTok); // Reserve a buffer to get the spelling. SmallString<128> FilenameBuffer; StringRef Filename; SourceLocation End; SourceLocation CharEnd; // the end of this directive, in characters switch (FilenameTok.getKind()) { case tok::eod: // If the token kind is EOD, the error has already been diagnosed. return; case tok::angle_string_literal: case tok::string_literal: Filename = getSpelling(FilenameTok, FilenameBuffer); End = FilenameTok.getLocation(); CharEnd = End.getLocWithOffset(FilenameTok.getLength()); break; case tok::less: // This could be a file coming from a macro expansion. In this // case, glue the tokens together into FilenameBuffer and interpret those. FilenameBuffer.push_back('<'); if (ConcatenateIncludeName(FilenameBuffer, End)) return; // Found but no ">"? Diagnostic already emitted. Filename = FilenameBuffer.str(); CharEnd = End.getLocWithOffset(1); break; default: Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename); DiscardUntilEndOfDirective(); return; } CharSourceRange FilenameRange = CharSourceRange::getCharRange(FilenameTok.getLocation(), CharEnd); StringRef OriginalFilename = Filename; bool isAngled = GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename); // If GetIncludeFilenameSpelling set the start ptr to null, there was an // error. if (Filename.empty()) { DiscardUntilEndOfDirective(); return; } // Verify that there is nothing after the filename, other than EOD. Note that // we allow macros that expand to nothing after the filename, because this // falls into the category of "#include pp-tokens new-line" specified in // C99 6.10.2p4. CheckEndOfDirective(IncludeTok.getIdentifierInfo()->getNameStart(), true); // Check that we don't have infinite #include recursion. if (IncludeMacroStack.size() == MaxAllowedIncludeStackDepth-1) { Diag(FilenameTok, diag::err_pp_include_too_deep); return; } // 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(); } if (HeaderInfo.HasIncludeAliasMap()) { // 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 // spelling for. StringRef NewName = HeaderInfo.MapHeaderToIncludeAlias(OriginalFilename); if (!NewName.empty()) Filename = NewName; } // Search include directories. const DirectoryLookup *CurDir; SmallString<1024> SearchPath; SmallString<1024> RelativePath; // We get the raw path only if we have 'Callbacks' to which we later pass // the path. ModuleMap::KnownHeader SuggestedModule; SourceLocation FilenameLoc = FilenameTok.getLocation(); const FileEntry *File = LookupFile( FilenameLoc, Filename, isAngled, LookupFrom, CurDir, Callbacks ? &SearchPath : NULL, Callbacks ? &RelativePath : NULL, HeaderInfo.getHeaderSearchOpts().ModuleMaps ? &SuggestedModule : 0); if (Callbacks) { if (!File) { // Give the clients a chance to recover. SmallString<128> RecoveryPath; if (Callbacks->FileNotFound(Filename, RecoveryPath)) { if (const DirectoryEntry *DE = FileMgr.getDirectory(RecoveryPath)) { // Add the recovery path to the list of search paths. DirectoryLookup DL(DE, SrcMgr::C_User, false); HeaderInfo.AddSearchPath(DL, isAngled); // Try the lookup again, skipping the cache. File = LookupFile(FilenameLoc, Filename, isAngled, LookupFrom, CurDir, 0, 0, HeaderInfo.getHeaderSearchOpts().ModuleMaps ? &SuggestedModule : 0, /*SkipCache*/ true); } } } if (!SuggestedModule || !getLangOpts().Modules) { // Notify the callback object that we've seen an inclusion directive. Callbacks->InclusionDirective(HashLoc, IncludeTok, Filename, isAngled, FilenameRange, File, SearchPath, RelativePath, /*ImportedModule=*/0); } } if (File == 0) { if (!SuppressIncludeNotFoundError) { // If the file could not be located and it was included via angle // brackets, we can attempt a lookup as though it were a quoted path to // provide the user with a possible fixit. if (isAngled) { File = LookupFile( FilenameLoc, Filename, false, LookupFrom, CurDir, Callbacks ? &SearchPath : 0, Callbacks ? &RelativePath : 0, HeaderInfo.getHeaderSearchOpts().ModuleMaps ? &SuggestedModule : 0); if (File) { SourceRange Range(FilenameTok.getLocation(), CharEnd); Diag(FilenameTok, diag::err_pp_file_not_found_not_fatal) << Filename << FixItHint::CreateReplacement(Range, "\"" + Filename.str() + "\""); } } // If the file is still not found, just go with the vanilla diagnostic if (!File) Diag(FilenameTok, diag::err_pp_file_not_found) << Filename; } if (!File) return; } // If we are supposed to import a module rather than including the header, // do so now. if (SuggestedModule && getLangOpts().Modules) { // Compute the module access path corresponding to this module. // FIXME: Should we have a second loadModule() overload to avoid this // extra lookup step? SmallVector, 2> Path; for (Module *Mod = SuggestedModule.getModule(); Mod; Mod = Mod->Parent) Path.push_back(std::make_pair(getIdentifierInfo(Mod->Name), FilenameTok.getLocation())); std::reverse(Path.begin(), Path.end()); // Warn that we're replacing the include/import with a module import. SmallString<128> PathString; for (unsigned I = 0, N = Path.size(); I != N; ++I) { if (I) PathString += '.'; PathString += Path[I].first->getName(); } int IncludeKind = 0; switch (IncludeTok.getIdentifierInfo()->getPPKeywordID()) { case tok::pp_include: IncludeKind = 0; break; case tok::pp_import: IncludeKind = 1; break; case tok::pp_include_next: IncludeKind = 2; break; case tok::pp___include_macros: IncludeKind = 3; break; default: llvm_unreachable("unknown include directive kind"); } // Determine whether we are actually building the module that this // include directive maps to. bool BuildingImportedModule = Path[0].first->getName() == getLangOpts().CurrentModule; if (!BuildingImportedModule && getLangOpts().ObjC2) { // If we're not building the imported module, warn that we're going // to automatically turn this inclusion directive into a module import. // We only do this in Objective-C, where we have a module-import syntax. CharSourceRange ReplaceRange(SourceRange(HashLoc, CharEnd), /*IsTokenRange=*/false); Diag(HashLoc, diag::warn_auto_module_import) << IncludeKind << PathString << FixItHint::CreateReplacement(ReplaceRange, "@@import " + PathString.str().str() + ";"); } // Load the module. Only make macros visible. We'll make the declarations // visible when the parser gets here. Module::NameVisibilityKind Visibility = Module::MacrosVisible; ModuleLoadResult Imported = TheModuleLoader.loadModule(IncludeTok.getLocation(), Path, Visibility, /*IsIncludeDirective=*/true); assert((Imported == 0 || Imported == SuggestedModule.getModule()) && "the imported module is different than the suggested one"); if (!Imported && 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); } return; } // If this header isn't part of the module we're building, we're done. if (!BuildingImportedModule && Imported) { if (Callbacks) { Callbacks->InclusionDirective(HashLoc, IncludeTok, Filename, isAngled, FilenameRange, File, SearchPath, RelativePath, Imported); } if (IncludeKind != 3) { // Let the parser know that we hit a module import, and it should // make the module visible. // FIXME: Produce this as the current token directly, rather than // allocating a new token for it. Token *Tok = new Token[1]; Tok[0].startToken(); Tok[0].setKind(tok::annot_module_include); Tok[0].setLocation(HashLoc); Tok[0].setAnnotationEndLoc(End); Tok[0].setAnnotationValue(Imported); EnterTokenStream(Tok, 1, true, true); } return; } // If we failed to find a submodule that we expected to find, we can // continue. Otherwise, there's an error in the included file, so we // don't want to include it. if (!BuildingImportedModule && !Imported.isMissingExpected()) { return; } } if (Callbacks && SuggestedModule) { // We didn't notify the callback object that we've seen an inclusion // directive before. Now that we are parsing the include normally and not // turning it to a module import, notify the callback object. Callbacks->InclusionDirective(HashLoc, IncludeTok, Filename, isAngled, FilenameRange, File, SearchPath, RelativePath, /*ImportedModule=*/0); } // The #included file will be considered to be a system header if either it is // in a system include directory, or if the #includer is a system include // header. SrcMgr::CharacteristicKind FileCharacter = std::max(HeaderInfo.getFileDirFlavor(File), SourceMgr.getFileCharacteristic(FilenameTok.getLocation())); // Ask HeaderInfo if we should enter this #include file. If not, #including // this file will have no effect. if (!HeaderInfo.ShouldEnterIncludeFile(File, isImport)) { if (Callbacks) Callbacks->FileSkipped(*File, FilenameTok, FileCharacter); return; } // Look up the file, create a File ID for it. 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); assert(!FID.isInvalid() && "Expected valid file ID"); // Finally, if all is good, enter the new file! EnterSourceFile(FID, CurDir, FilenameTok.getLocation()); } /// HandleIncludeNextDirective - Implements \#include_next. /// void Preprocessor::HandleIncludeNextDirective(SourceLocation HashLoc, Token &IncludeNextTok) { Diag(IncludeNextTok, diag::ext_pp_include_next_directive); // #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; if (isInPrimaryFile()) { Lookup = 0; Diag(IncludeNextTok, diag::pp_include_next_in_primary); } else if (Lookup == 0) { Diag(IncludeNextTok, diag::pp_include_next_absolute_path); } else { // Start looking up in the next directory. ++Lookup; } return HandleIncludeDirective(HashLoc, IncludeNextTok, Lookup); } /// HandleMicrosoftImportDirective - Implements \#import for Microsoft Mode 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 ); // Read tokens until we get to the end of the directive. Note that the // directive can be split over multiple lines using the backslash character. DiscardUntilEndOfDirective(); } /// HandleImportDirective - Implements \#import. /// void Preprocessor::HandleImportDirective(SourceLocation HashLoc, Token &ImportTok) { if (!LangOpts.ObjC1) { // #import is standard for ObjC. if (LangOpts.MicrosoftMode) return HandleMicrosoftImportDirective(ImportTok); Diag(ImportTok, diag::ext_pp_import_directive); } return HandleIncludeDirective(HashLoc, ImportTok, 0, true); } /// 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). void Preprocessor::HandleIncludeMacrosDirective(SourceLocation HashLoc, Token &IncludeMacrosTok) { // 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), "") != 0) { Diag(IncludeMacrosTok.getLocation(), diag::pp_include_macros_out_of_predefines); DiscardUntilEndOfDirective(); return; } // Treat this as a normal #include for checking purposes. If this is // successful, it will push a new lexer onto the include stack. HandleIncludeDirective(HashLoc, IncludeMacrosTok, 0, false); Token TmpTok; do { Lex(TmpTok); assert(TmpTok.isNot(tok::eof) && "Didn't find end of -imacros!"); } while (TmpTok.isNot(tok::hashhash)); } //===----------------------------------------------------------------------===// // 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. bool Preprocessor::ReadMacroDefinitionArgList(MacroInfo *MI, Token &Tok) { SmallVector Arguments; while (1) { LexUnexpandedToken(Tok); switch (Tok.getKind()) { case tok::r_paren: // Found the end of the argument list. if (Arguments.empty()) // #define FOO() 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 if (!LangOpts.C99) Diag(Tok, LangOpts.CPlusPlus11 ? diag::warn_cxx98_compat_variadic_macro : diag::ext_variadic_macro); // OpenCL v1.2 s6.9.e: variadic macros are not supported. if (LangOpts.OpenCL) { Diag(Tok, diag::err_pp_opencl_variadic_macros); return true; } // 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(); MI->setArgumentList(&Arguments[0], Arguments.size(), BP); return false; case tok::eod: // #define X( 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(); if (II == 0) { // #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. if (std::find(Arguments.begin(), Arguments.end(), II) != Arguments.end()) { // C99 6.10.3p6 Diag(Tok, diag::err_pp_duplicate_name_in_arg_list) << II; return true; } // Add the argument to the macro info. Arguments.push_back(II); // Lex the token after the identifier. LexUnexpandedToken(Tok); 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) MI->setArgumentList(&Arguments[0], Arguments.size(), BP); 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); // 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; } MI->setIsGNUVarargs(); MI->setArgumentList(&Arguments[0], Arguments.size(), BP); return false; } } } } /// HandleDefineDirective - Implements \#define. This consumes the entire macro /// line then lets the caller lex the next real token. void Preprocessor::HandleDefineDirective(Token &DefineTok, bool ImmediatelyAfterHeaderGuard) { ++NumDefined; Token MacroNameTok; ReadMacroName(MacroNameTok, 1); // Error reading macro name? If so, diagnostic already issued. if (MacroNameTok.is(tok::eod)) return; Token LastTok = MacroNameTok; // If we are supposed to keep comments in #defines, reenable comment saving // mode. if (CurLexer) CurLexer->SetCommentRetentionState(KeepMacroComments); // Create the new macro. MacroInfo *MI = AllocateMacroInfo(MacroNameTok.getLocation()); Token Tok; LexUnexpandedToken(Tok); // 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. if (Tok.is(tok::eod)) { if (ImmediatelyAfterHeaderGuard) { // Save this macro information since it may part of a header guard. CurPPLexer->MIOpt.SetDefinedMacro(MacroNameTok.getIdentifierInfo(), MacroNameTok.getLocation()); } // If there is no body to this macro, we have no special handling here. } 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)) { // This is a function-like macro definition. Read the argument list. MI->setIsFunctionLike(); if (ReadMacroDefinitionArgList(MI, LastTok)) { // Forget about MI. ReleaseMacroInfo(MI); // Throw away the rest of the line. if (CurPPLexer->ParsingPreprocessorDirective) DiscardUntilEndOfDirective(); return; } // If this is a definition of a variadic C99 function-like macro, not using // the GNU named varargs extension, enabled __VA_ARGS__. // "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); // Read the first token after the arg list for down below. LexUnexpandedToken(Tok); } else if (LangOpts.C99 || LangOpts.CPlusPlus11) { // C99 requires whitespace between the macro definition and the body. Emit // a diagnostic for something like "#define X+". Diag(Tok, diag::ext_c99_whitespace_required_after_macro_name); } else { // 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); } if (!Tok.is(tok::eod)) LastTok = Tok; // Read the rest of the macro body. if (MI->isObjectLike()) { // Object-like macros are very simple, just read their body. while (Tok.isNot(tok::eod)) { LastTok = Tok; MI->AddTokenToBody(Tok); // Get the next token of the macro. LexUnexpandedToken(Tok); } } else { // 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. while (Tok.isNot(tok::eod)) { LastTok = Tok; if (Tok.isNot(tok::hash) && Tok.isNot(tok::hashhash)) { MI->AddTokenToBody(Tok); // Get the next token of the macro. LexUnexpandedToken(Tok); continue; } // 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; } 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. // 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(); // Things look ok, add the '##' token to the macro. MI->AddTokenToBody(LastTok); continue; } // Get the next token of the macro. LexUnexpandedToken(Tok); // Check for a valid macro arg identifier. if (Tok.getIdentifierInfo() == 0 || 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. if (getLangOpts().AsmPreprocessor && Tok.isNot(tok::eod)) { LastTok.setKind(tok::unknown); MI->AddTokenToBody(LastTok); continue; } else { Diag(Tok, diag::err_pp_stringize_not_parameter); ReleaseMacroInfo(MI); // Disable __VA_ARGS__ again. Ident__VA_ARGS__->setIsPoisoned(true); return; } } // Things look ok, add the '#' and param name tokens to the macro. MI->AddTokenToBody(LastTok); MI->AddTokenToBody(Tok); LastTok = Tok; // Get the next token of the macro. LexUnexpandedToken(Tok); } } // Disable __VA_ARGS__ again. Ident__VA_ARGS__->setIsPoisoned(true); // Check that there is no paste (##) operator at the beginning or end of the // 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); ReleaseMacroInfo(MI); return; } if (MI->getReplacementToken(NumTokens-1).is(tok::hashhash)) { Diag(MI->getReplacementToken(NumTokens-1), diag::err_paste_at_end); ReleaseMacroInfo(MI); return; } } MI->setDefinitionEndLoc(LastTok.getLocation()); // Finally, if this identifier already had a macro defined for it, verify that // the macro bodies are identical, and issue diagnostics if they are not. if (const MacroInfo *OtherMI=getMacroInfo(MacroNameTok.getIdentifierInfo())) { // 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. if (!getDiagnostics().getSuppressSystemWarnings() || !SourceMgr.isInSystemHeader(DefineTok.getLocation())) { if (!OtherMI->isUsed() && OtherMI->isWarnIfUnused()) Diag(OtherMI->getDefinitionLoc(), diag::pp_macro_not_used); // Warn if defining "__LINE__" and other builtins, per C99 6.10.8/4 and // C++ [cpp.predefined]p4, but allow it as an extension. if (OtherMI->isBuiltinMacro()) Diag(MacroNameTok, diag::ext_pp_redef_builtin_macro); // Macros must be identical. This means all tokens and whitespace // separation must be the same. C99 6.10.3p2. else if (!OtherMI->isAllowRedefinitionsWithoutWarning() && !MI->isIdenticalTo(*OtherMI, *this, /*Syntactic=*/LangOpts.MicrosoftExt)) { Diag(MI->getDefinitionLoc(), diag::ext_pp_macro_redef) << MacroNameTok.getIdentifierInfo(); Diag(OtherMI->getDefinitionLoc(), diag::note_previous_definition); } } if (OtherMI->isWarnIfUnused()) WarnUnusedMacroLocs.erase(OtherMI->getDefinitionLoc()); } DefMacroDirective *MD = appendDefMacroDirective(MacroNameTok.getIdentifierInfo(), MI); 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. if (getSourceManager().isInMainFile(MI->getDefinitionLoc()) && Diags->getDiagnosticLevel(diag::pp_macro_not_used, MI->getDefinitionLoc()) != DiagnosticsEngine::Ignored) { MI->setIsWarnIfUnused(true); WarnUnusedMacroLocs.insert(MI->getDefinitionLoc()); } // If the callbacks want to know, tell them about the macro definition. if (Callbacks) Callbacks->MacroDefined(MacroNameTok, MD); } /// HandleUndefDirective - Implements \#undef. /// void Preprocessor::HandleUndefDirective(Token &UndefTok) { ++NumUndefined; Token MacroNameTok; ReadMacroName(MacroNameTok, 2); // Error reading macro name? If so, diagnostic already issued. if (MacroNameTok.is(tok::eod)) return; // Check to see if this is the last token on the #undef line. CheckEndOfDirective("undef"); // Okay, we finally have a valid identifier to undef. MacroDirective *MD = getMacroDirective(MacroNameTok.getIdentifierInfo()); const MacroInfo *MI = MD ? MD->getMacroInfo() : 0; // If the callbacks want to know, tell them about the macro #undef. // Note: no matter if the macro was defined or not. if (Callbacks) Callbacks->MacroUndefined(MacroNameTok, MD); // If the macro is not defined, this is a noop undef, just return. if (MI == 0) return; if (!MI->isUsed() && MI->isWarnIfUnused()) Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used); if (MI->isWarnIfUnused()) WarnUnusedMacroLocs.erase(MI->getDefinitionLoc()); appendMacroDirective(MacroNameTok.getIdentifierInfo(), AllocateUndefMacroDirective(MacroNameTok.getLocation())); } //===----------------------------------------------------------------------===// // Preprocessor Conditional Directive Handling. //===----------------------------------------------------------------------===// /// 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. /// void Preprocessor::HandleIfdefDirective(Token &Result, bool isIfndef, bool ReadAnyTokensBeforeDirective) { ++NumIf; Token DirectiveTok = Result; Token MacroNameTok; ReadMacroName(MacroNameTok); // Error reading macro name? If so, diagnostic already issued. if (MacroNameTok.is(tok::eod)) { // 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; } // Check to see if this is the last token on the #if[n]def line. CheckEndOfDirective(isIfndef ? "ifndef" : "ifdef"); IdentifierInfo *MII = MacroNameTok.getIdentifierInfo(); MacroDirective *MD = getMacroDirective(MII); MacroInfo *MI = MD ? MD->getMacroInfo() : 0; if (CurPPLexer->getConditionalStackDepth() == 0) { // 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. if (!ReadAnyTokensBeforeDirective && MI == 0) { assert(isIfndef && "#ifdef shouldn't reach here"); CurPPLexer->MIOpt.EnterTopLevelIfndef(MII, MacroNameTok.getLocation()); } else CurPPLexer->MIOpt.EnterTopLevelConditional(); } // If there is a macro, process it. if (MI) // Mark it used. markMacroAsUsed(MI); if (Callbacks) { if (isIfndef) Callbacks->Ifndef(DirectiveTok.getLocation(), MacroNameTok, MD); else Callbacks->Ifdef(DirectiveTok.getLocation(), MacroNameTok, MD); } // 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. CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(), /*wasskip*/false, /*foundnonskip*/true, /*foundelse*/false); } else { // No, skip the contents of this block. SkipExcludedConditionalBlock(DirectiveTok.getLocation(), /*Foundnonskip*/false, /*FoundElse*/false); } } /// HandleIfDirective - Implements the \#if directive. /// void Preprocessor::HandleIfDirective(Token &IfToken, bool ReadAnyTokensBeforeDirective) { ++NumIf; // Parse and evaluate the conditional expression. IdentifierInfo *IfNDefMacro = 0; const SourceLocation ConditionalBegin = CurPPLexer->getSourceLocation(); const bool ConditionalTrue = EvaluateDirectiveExpression(IfNDefMacro); const SourceLocation ConditionalEnd = CurPPLexer->getSourceLocation(); // If this condition is equivalent to #ifndef X, and if this is the first // directive seen, handle it for the multiple-include optimization. if (CurPPLexer->getConditionalStackDepth() == 0) { if (!ReadAnyTokensBeforeDirective && IfNDefMacro && ConditionalTrue) // FIXME: Pass in the location of the macro name, not the 'if' token. CurPPLexer->MIOpt.EnterTopLevelIfndef(IfNDefMacro, IfToken.getLocation()); else CurPPLexer->MIOpt.EnterTopLevelConditional(); } if (Callbacks) Callbacks->If(IfToken.getLocation(), SourceRange(ConditionalBegin, ConditionalEnd), ConditionalTrue); // Should we include the stuff contained by this directive? if (ConditionalTrue) { // Yes, remember that we are inside a conditional, then lex the next token. CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false, /*foundnonskip*/true, /*foundelse*/false); } else { // No, skip the contents of this block. SkipExcludedConditionalBlock(IfToken.getLocation(), /*Foundnonskip*/false, /*FoundElse*/false); } } /// HandleEndifDirective - Implements the \#endif directive. /// void Preprocessor::HandleEndifDirective(Token &EndifToken) { ++NumEndif; // Check that this is the whole directive. CheckEndOfDirective("endif"); PPConditionalInfo CondInfo; if (CurPPLexer->popConditionalLevel(CondInfo)) { // No conditionals on the stack: this is an #endif without an #if. Diag(EndifToken, diag::err_pp_endif_without_if); return; } // If this the end of a top-level #endif, inform MIOpt. if (CurPPLexer->getConditionalStackDepth() == 0) CurPPLexer->MIOpt.ExitTopLevelConditional(); assert(!CondInfo.WasSkipping && !CurPPLexer->LexingRawMode && "This code should only be reachable in the non-skipping case!"); if (Callbacks) Callbacks->Endif(EndifToken.getLocation(), CondInfo.IfLoc); } /// HandleElseDirective - Implements the \#else directive. /// void Preprocessor::HandleElseDirective(Token &Result) { ++NumElse; // #else directive in a non-skipping conditional... start skipping. CheckEndOfDirective("else"); PPConditionalInfo CI; if (CurPPLexer->popConditionalLevel(CI)) { Diag(Result, diag::pp_err_else_without_if); return; } // If this is a top-level #else, inform the MIOpt. if (CurPPLexer->getConditionalStackDepth() == 0) CurPPLexer->MIOpt.EnterTopLevelConditional(); // If this is a #else with a #else before it, report the error. if (CI.FoundElse) Diag(Result, diag::pp_err_else_after_else); if (Callbacks) Callbacks->Else(Result.getLocation(), CI.IfLoc); // Finally, skip the rest of the contents of this block. SkipExcludedConditionalBlock(CI.IfLoc, /*Foundnonskip*/true, /*FoundElse*/true, Result.getLocation()); } /// HandleElifDirective - Implements the \#elif directive. /// void Preprocessor::HandleElifDirective(Token &ElifToken) { ++NumElse; // #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). const SourceLocation ConditionalBegin = CurPPLexer->getSourceLocation(); DiscardUntilEndOfDirective(); const SourceLocation ConditionalEnd = CurPPLexer->getSourceLocation(); PPConditionalInfo CI; if (CurPPLexer->popConditionalLevel(CI)) { Diag(ElifToken, diag::pp_err_elif_without_if); return; } // If this is a top-level #elif, inform the MIOpt. if (CurPPLexer->getConditionalStackDepth() == 0) CurPPLexer->MIOpt.EnterTopLevelConditional(); // If this is a #elif with a #else before it, report the error. if (CI.FoundElse) Diag(ElifToken, diag::pp_err_elif_after_else); if (Callbacks) Callbacks->Elif(ElifToken.getLocation(), SourceRange(ConditionalBegin, ConditionalEnd), true, CI.IfLoc); // Finally, skip the rest of the contents of this block. SkipExcludedConditionalBlock(CI.IfLoc, /*Foundnonskip*/true, /*FoundElse*/CI.FoundElse, ElifToken.getLocation()); } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @d407 2 a408 3 // If this is a #elif with a #else before it, report the error. if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_elif_after_else); d413 1 a414 1 const SourceLocation CondBegin = CurPPLexer->getSourceLocation(); d420 1 a420 1 const bool CondValue = EvaluateDirectiveExpression(IfNDefMacro); d422 10 a431 2 if (Callbacks) { const SourceLocation CondEnd = CurPPLexer->getSourceLocation(); d433 3 a435 8 SourceRange(CondBegin, CondEnd), (CondValue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False), CondInfo.IfLoc); } // If this condition is true, enter it! if (CondValue) { CondInfo.FoundNonSkip = true; break; } d543 1 a543 2 // FIXME: Look into directly passing the FileEntry from LookupFile instead. FileID IDOfIncl = SourceMgr.getFileID(SourceMgr.getSpellingLoc(FilenameLoc)); d554 63 d627 3 a629 3 // If the header lookup mechanism may be relative to the current inclusion // stack, record the parent #includes. SmallVector Includers; d632 1 a632 1 const FileEntry *FileEnt = SourceMgr.getFileEntryForID(FID); d640 3 a642 17 if (!FileEnt) FileEnt = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID()); if (FileEnt) Includers.push_back(FileEnt); // 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 if (LangOpts.MicrosoftMode && !isAngled) { for (unsigned i = 0, e = IncludeMacroStack.size(); i != e; ++i) { IncludeStackInfo &ISEntry = IncludeMacroStack[e - i - 1]; if (IsFileLexer(ISEntry)) if ((FileEnt = SourceMgr.getFileEntryForID( ISEntry.ThePPLexer->getFileID()))) Includers.push_back(FileEnt); } d649 2 a650 2 Filename, FilenameLoc, isAngled, FromDir, CurDir, Includers, SearchPath, RelativePath, SuggestedModule, SkipCache); d653 1 a653 2 HeaderInfo.getModuleMap().diagnoseHeaderInclusion( getModuleForLocation(FilenameLoc), FilenameLoc, Filename, FE); a656 1 const FileEntry *CurFileEnt; d1330 15 a1344 14 // \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 // \#include FOO // \endcode // because in this case, "" 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, a1391 13 /// \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) { Token *Tok = new Token[1]; Tok[0].startToken(); Tok[0].setKind(Kind); Tok[0].setLocation(Begin); Tok[0].setAnnotationEndLoc(End); Tok[0].setAnnotationValue(AnnotationVal); PP.EnterTokenStream(Tok, 1, true, true); } d1593 1 a1593 1 d1642 7 a1648 2 EnterAnnotationToken(*this, HashLoc, End, tok::annot_module_include, Imported); d1695 2 a1696 17 // Determine if we're switching to building a new submodule, and which one. ModuleMap::KnownHeader BuildingModule; if (getLangOpts().Modules && !getLangOpts().CurrentModule.empty()) { Module *RequestingModule = getModuleForLocation(FilenameLoc); BuildingModule = HeaderInfo.getModuleMap().findModuleForHeader(File, RequestingModule); } // If all is good, enter the new file! EnterSourceFile(FID, CurDir, FilenameTok.getLocation(), static_cast(BuildingModule)); // If we're walking into another part of the same module, let the parser // know that any future declarations are within that other submodule. if (BuildingModule) EnterAnnotationToken(*this, HashLoc, End, tok::annot_module_begin, BuildingModule.getModule()); d2262 1 a2262 1 (ConditionalTrue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False)); d2359 1 a2359 1 PPCallbacks::CVK_NotEvaluated, CI.IfLoc); @ 1.1.1.3 log @Import Clang 3.5svn r199312 @ text @d165 1 a165 1 if (Info.isCPlusPlusOperatorKeyword() && getLangOpts().MSVCCompat) { d585 1 a585 1 if (LangOpts.MSVCCompat && !isAngled) { d1715 1 a1715 1 if (LangOpts.MSVCCompat) @ 1.1.1.4 log @Import Clang 3.5svn r201163. @ text @d1663 2 a1664 2 if (EnterSourceFile(FID, CurDir, FilenameTok.getLocation())) return; d1668 1 a1668 4 if (BuildingModule) { assert(!CurSubmodule && "should not have marked this as a module yet"); CurSubmodule = BuildingModule.getModule(); d1670 1 a1670 2 CurSubmodule); } @ 1.1.1.4.2.1 log @Rebase. @ text @a27 1 #include "llvm/Support/FileSystem.h" d47 1 a47 1 MIChain->Prev = nullptr; d63 2 a64 2 static_assert(llvm::AlignOf::Alignment >= sizeof(SubModuleID), "alignment for MacroInfo is less than the ID"); d113 1 a113 1 MIChainHead->Prev = nullptr; d131 18 a148 1 bool Preprocessor::CheckMacroName(Token &MacroNameTok, char isDefineUndef) { d150 4 a153 2 if (MacroNameTok.is(tok::eod)) return Diag(MacroNameTok, diag::err_pp_missing_macro_name); d156 1 a156 1 if (!II) { d160 1 a160 1 return Diag(MacroNameTok, diag::err_pp_macro_not_identifier); d167 1 a167 1 return false; d173 5 a177 7 return Diag(MacroNameTok, diag::err_pp_operator_used_as_macro_name) << Spelling << MacroNameTok.getKind(); return Diag(MacroNameTok, diag::err_pp_macro_not_identifier); } if (isDefineUndef && II->getPPKeywordID() == tok::pp_defined) { d179 3 a181 5 return Diag(MacroNameTok, diag::err_defined_macro_name); } if (isDefineUndef == 2 && II->hasMacroDefinition() && getMacroInfo(II)->isBuiltinMacro()) { d185 4 d191 4 a194 31 // Okay, we got a good identifier. return false; } /// \brief Lex and validate a macro name, which occurs after a /// \#define or \#undef. /// /// This sets the token kind to eod and discards the rest /// of the macro line if the macro name is invalid. \p isDefineUndef is 1 if /// this is due to a a \#define, 2 if \#undef directive, 0 if it is something /// else (e.g. \#ifdef). void Preprocessor::ReadMacroName(Token &MacroNameTok, char isDefineUndef) { // Read the token, don't allow macro expansion on it. LexUnexpandedToken(MacroNameTok); if (MacroNameTok.is(tok::code_completion)) { if (CodeComplete) CodeComplete->CodeCompleteMacroName(isDefineUndef == 1); setCodeCompletionReached(); LexUnexpandedToken(MacroNameTok); } if (!CheckMacroName(MacroNameTok, isDefineUndef)) 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(); } d312 1 a312 1 StringRef RI = Tok.getRawIdentifier(); d314 1 a314 1 char FirstChar = RI[0]; d328 2 a329 2 if (!Tok.needsCleaning() && RI.size() < 20) { Directive = RI; d420 1 a420 1 IdentifierInfo *IfNDefMacro = nullptr; d517 1 a517 1 IdentifierInfo *IfNDefMacro = nullptr; d542 1 a542 1 FileID IDOfIncl = SourceMgr.getFileID(SourceMgr.getExpansionLoc(FilenameLoc)); d602 1 a602 1 if (SuggestedModule && !LangOpts.AsmPreprocessor) d613 1 a613 1 if ((CurFileEnt = SourceMgr.getFileEntryForID(CurPPLexer->getFileID()))) { d616 1 a616 4 SuggestedModule))) { if (SuggestedModule && !LangOpts.AsmPreprocessor) HeaderInfo.getModuleMap().diagnoseHeaderInclusion( getModuleForLocation(FilenameLoc), FilenameLoc, Filename, FE); a617 2 } } d624 1 a624 1 SourceMgr.getFileEntryForID(ISEntry.ThePPLexer->getFileID()))) { d627 1 a627 4 SuggestedModule))) { if (SuggestedModule && !LangOpts.AsmPreprocessor) HeaderInfo.getModuleMap().diagnoseHeaderInclusion( getModuleForLocation(FilenameLoc), FilenameLoc, Filename, FE); a628 2 } } d633 1 a633 1 return nullptr; d731 1 a731 1 if (!II) break; // Not an identifier. d1196 1 a1196 1 if (!MD) { d1223 1 a1223 1 if (!MD) { a1451 5 SmallString<128> NormalizedPath; if (LangOpts.MSVCCompat) { NormalizedPath = Filename.str(); llvm::sys::fs::normalize_separators(NormalizedPath); } d1453 3 a1455 4 FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled, LookupFrom, CurDir, Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr, HeaderInfo.getHeaderSearchOpts().ModuleMaps ? &SuggestedModule : nullptr); d1468 2 a1469 5 File = LookupFile(FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled, LookupFrom, CurDir, nullptr, nullptr, HeaderInfo.getHeaderSearchOpts().ModuleMaps d1471 1 a1471 1 : nullptr, d1479 4 a1482 5 Callbacks->InclusionDirective(HashLoc, IncludeTok, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled, FilenameRange, File, SearchPath, RelativePath, /*ImportedModule=*/nullptr); d1485 2 a1486 2 if (!File) { d1493 3 a1495 5 FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, false, LookupFrom, CurDir, Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr, HeaderInfo.getHeaderSearchOpts().ModuleMaps ? &SuggestedModule : nullptr); d1576 1 a1576 1 assert((Imported == nullptr || Imported == SuggestedModule.getModule()) && d1627 1 a1627 1 /*ImportedModule=*/nullptr); d1688 1 a1688 1 Lookup = nullptr; d1690 1 a1690 1 } else if (!Lookup) { d1723 1 a1723 1 return HandleIncludeDirective(HashLoc, ImportTok, nullptr, true); d1744 1 a1744 1 HandleIncludeDirective(HashLoc, IncludeMacrosTok, nullptr, false); d1804 1 a1804 1 if (!II) { d2008 1 a2008 1 if (Tok.getIdentifierInfo() == nullptr || d2124 1 a2124 1 const MacroInfo *MI = MD ? MD->getMacroInfo() : nullptr; d2132 1 a2132 2 if (!MI) return; d2176 1 a2176 1 MacroInfo *MI = MD ? MD->getMacroInfo() : nullptr; d2183 1 a2183 1 if (!ReadAnyTokensBeforeDirective && !MI) { d2222 1 a2222 1 IdentifierInfo *IfNDefMacro = nullptr; @ 1.1.1.5 log @Import Clang 3.5svn r209886. @ text @a27 1 #include "llvm/Support/FileSystem.h" d47 1 a47 1 MIChain->Prev = nullptr; d63 2 a64 2 static_assert(llvm::AlignOf::Alignment >= sizeof(SubModuleID), "alignment for MacroInfo is less than the ID"); d113 1 a113 1 MIChainHead->Prev = nullptr; d131 18 a148 1 bool Preprocessor::CheckMacroName(Token &MacroNameTok, char isDefineUndef) { d150 4 a153 2 if (MacroNameTok.is(tok::eod)) return Diag(MacroNameTok, diag::err_pp_missing_macro_name); d156 1 a156 1 if (!II) { d160 1 a160 1 return Diag(MacroNameTok, diag::err_pp_macro_not_identifier); d167 1 a167 1 return false; d173 5 a177 7 return Diag(MacroNameTok, diag::err_pp_operator_used_as_macro_name) << Spelling << MacroNameTok.getKind(); return Diag(MacroNameTok, diag::err_pp_macro_not_identifier); } if (isDefineUndef && II->getPPKeywordID() == tok::pp_defined) { d179 3 a181 5 return Diag(MacroNameTok, diag::err_defined_macro_name); } if (isDefineUndef == 2 && II->hasMacroDefinition() && getMacroInfo(II)->isBuiltinMacro()) { d185 4 d191 4 a194 31 // Okay, we got a good identifier. return false; } /// \brief Lex and validate a macro name, which occurs after a /// \#define or \#undef. /// /// This sets the token kind to eod and discards the rest /// of the macro line if the macro name is invalid. \p isDefineUndef is 1 if /// this is due to a a \#define, 2 if \#undef directive, 0 if it is something /// else (e.g. \#ifdef). void Preprocessor::ReadMacroName(Token &MacroNameTok, char isDefineUndef) { // Read the token, don't allow macro expansion on it. LexUnexpandedToken(MacroNameTok); if (MacroNameTok.is(tok::code_completion)) { if (CodeComplete) CodeComplete->CodeCompleteMacroName(isDefineUndef == 1); setCodeCompletionReached(); LexUnexpandedToken(MacroNameTok); } if (!CheckMacroName(MacroNameTok, isDefineUndef)) 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(); } d312 1 a312 1 StringRef RI = Tok.getRawIdentifier(); d314 1 a314 1 char FirstChar = RI[0]; d328 2 a329 2 if (!Tok.needsCleaning() && RI.size() < 20) { Directive = RI; d420 1 a420 1 IdentifierInfo *IfNDefMacro = nullptr; d517 1 a517 1 IdentifierInfo *IfNDefMacro = nullptr; d542 1 a542 1 FileID IDOfIncl = SourceMgr.getFileID(SourceMgr.getExpansionLoc(FilenameLoc)); d602 1 a602 1 if (SuggestedModule && !LangOpts.AsmPreprocessor) d613 1 a613 1 if ((CurFileEnt = SourceMgr.getFileEntryForID(CurPPLexer->getFileID()))) { d616 1 a616 4 SuggestedModule))) { if (SuggestedModule && !LangOpts.AsmPreprocessor) HeaderInfo.getModuleMap().diagnoseHeaderInclusion( getModuleForLocation(FilenameLoc), FilenameLoc, Filename, FE); a617 2 } } d624 1 a624 1 SourceMgr.getFileEntryForID(ISEntry.ThePPLexer->getFileID()))) { d627 1 a627 4 SuggestedModule))) { if (SuggestedModule && !LangOpts.AsmPreprocessor) HeaderInfo.getModuleMap().diagnoseHeaderInclusion( getModuleForLocation(FilenameLoc), FilenameLoc, Filename, FE); a628 2 } } d633 1 a633 1 return nullptr; d731 1 a731 1 if (!II) break; // Not an identifier. d1196 1 a1196 1 if (!MD) { d1223 1 a1223 1 if (!MD) { a1451 5 SmallString<128> NormalizedPath; if (LangOpts.MSVCCompat) { NormalizedPath = Filename.str(); llvm::sys::fs::normalize_separators(NormalizedPath); } d1453 3 a1455 4 FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled, LookupFrom, CurDir, Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr, HeaderInfo.getHeaderSearchOpts().ModuleMaps ? &SuggestedModule : nullptr); d1468 2 a1469 5 File = LookupFile(FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled, LookupFrom, CurDir, nullptr, nullptr, HeaderInfo.getHeaderSearchOpts().ModuleMaps d1471 1 a1471 1 : nullptr, d1479 4 a1482 5 Callbacks->InclusionDirective(HashLoc, IncludeTok, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled, FilenameRange, File, SearchPath, RelativePath, /*ImportedModule=*/nullptr); d1485 2 a1486 2 if (!File) { d1493 3 a1495 5 FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, false, LookupFrom, CurDir, Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr, HeaderInfo.getHeaderSearchOpts().ModuleMaps ? &SuggestedModule : nullptr); d1576 1 a1576 1 assert((Imported == nullptr || Imported == SuggestedModule.getModule()) && d1627 1 a1627 1 /*ImportedModule=*/nullptr); d1688 1 a1688 1 Lookup = nullptr; d1690 1 a1690 1 } else if (!Lookup) { d1723 1 a1723 1 return HandleIncludeDirective(HashLoc, ImportTok, nullptr, true); d1744 1 a1744 1 HandleIncludeDirective(HashLoc, IncludeMacrosTok, nullptr, false); d1804 1 a1804 1 if (!II) { d2008 1 a2008 1 if (Tok.getIdentifierInfo() == nullptr || d2124 1 a2124 1 const MacroInfo *MI = MD ? MD->getMacroInfo() : nullptr; d2132 1 a2132 2 if (!MI) return; d2176 1 a2176 1 MacroInfo *MI = MD ? MD->getMacroInfo() : nullptr; d2183 1 a2183 1 if (!ReadAnyTokensBeforeDirective && !MI) { d2222 1 a2222 1 IdentifierInfo *IfNDefMacro = nullptr; @ 1.1.1.6 log @Import clang 3.6svn r215315. @ text @d28 1 a28 1 #include "llvm/Support/Path.h" d37 10 a46 1 MacroInfoChain *MIChain = BP.Allocate(); d48 3 d52 2 a53 1 return &MIChain->MI; d80 4 a83 7 unsigned ImportedFromModuleID, ArrayRef Overrides) { unsigned NumExtra = (ImportedFromModuleID ? 1 : 0) + Overrides.size(); return new (BP.Allocate(sizeof(DefMacroDirective) + sizeof(unsigned) * NumExtra, llvm::alignOf())) DefMacroDirective(MI, Loc, ImportedFromModuleID, Overrides); d87 4 a90 8 Preprocessor::AllocateUndefMacroDirective(SourceLocation UndefLoc, unsigned ImportedFromModuleID, ArrayRef Overrides) { unsigned NumExtra = (ImportedFromModuleID ? 1 : 0) + Overrides.size(); return new (BP.Allocate(sizeof(UndefMacroDirective) + sizeof(unsigned) * NumExtra, llvm::alignOf())) UndefMacroDirective(UndefLoc, ImportedFromModuleID, Overrides); d96 24 a119 1 return new (BP) VisibilityMacroDirective(Loc, isPublic); a142 1 II = getIdentifierInfo(Spelling); d144 13 a156 2 if (!II->isCPlusPlusOperatorKeyword()) return Diag(MacroNameTok, diag::err_pp_macro_not_identifier); d158 1 a158 10 // 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(); // Allow #defining |and| and friends for Microsoft compatibility or // recovery when legacy C headers are included in C++. MacroNameTok.setIdentifierInfo(II); d960 1 a960 1 StringLiteralParser Literal(StrTok, *this); d1096 1 a1096 1 StringLiteralParser Literal(StrTok, *this); d1474 1 a1474 3 #ifndef LLVM_ON_WIN32 llvm::sys::path::native(NormalizedPath); #endif d1544 1 a1544 3 if (SuggestedModule && getLangOpts().Modules && SuggestedModule.getModule()->getTopLevelModuleName() != getLangOpts().ImplementationOfModule) { d1926 2 d2052 1 d2080 1 d2085 1 d2127 2 a2128 1 !Diags->isIgnored(diag::pp_macro_not_used, MI->getDefinitionLoc())) { @ 1.1.1.6.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d103 1 a103 50 /// \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) { const LangOptions &Lang = PP.getLangOpts(); StringRef Text = II->getName(); if (isReservedId(Text, Lang)) return MD_ReservedMacro; if (II->isKeyword(Lang)) return MD_KeywordDef; if (Lang.CPlusPlus11 && (Text.equals("override") || Text.equals("final"))) return MD_KeywordDef; return MD_NoWarn; } 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; } bool Preprocessor::CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef, bool *ShadowFlag) { d131 1 a131 1 if ((isDefineUndef != MU_Other) && II->getPPKeywordID() == tok::pp_defined) { d136 1 a136 1 if (isDefineUndef == MU_Undef && II->hasMacroDefinition() && a142 24 // If defining/undefining reserved identifier or a keyword, we need to issue // a warning. SourceLocation MacroNameLoc = MacroNameTok.getLocation(); if (ShadowFlag) *ShadowFlag = false; if (!SourceMgr.isInSystemHeader(MacroNameLoc) && (strcmp(SourceMgr.getBufferName(MacroNameLoc), "") != 0)) { 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); } d150 5 a154 8 /// 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. /// \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) { d160 1 a160 1 CodeComplete->CodeCompleteMacroName(isDefineUndef == MU_Define); d165 1 a165 1 if (!CheckMacroName(MacroNameTok, isDefineUndef, ShadowFlag)) a536 1 const FileEntry *FromFile, d544 2 a545 3 SmallVector, 16> Includers; if (!FromDir && !FromFile) { d550 10 a559 20 // 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. if (!FileEnt) { if (FID == SourceMgr.getMainFileID() && MainFileDir) Includers.push_back(std::make_pair(nullptr, MainFileDir)); else if ((FileEnt = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID()))) Includers.push_back(std::make_pair(FileEnt, FileMgr.getDirectory("."))); } else { Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir())); } d570 1 a570 1 Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir())); d575 1 a576 23 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, Includers, SearchPath, RelativePath, SuggestedModule, SkipCache)) { // 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. d691 1 a691 2 case tok::pp_pragma: Diag(Result, diag::err_embedded_directive) << II->getName(); d1171 1 a1171 1 ReadMacroName(MacroNameTok, MU_Undef); d1198 1 a1198 1 ReadMacroName(MacroNameTok, MU_Undef); a1352 1 const FileEntry *LookupFromFile, d1450 2 a1451 2 isAngled, LookupFrom, LookupFromFile, CurDir, Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr, d1465 8 a1472 7 File = LookupFile( FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled, LookupFrom, LookupFromFile, CurDir, nullptr, nullptr, HeaderInfo.getHeaderSearchOpts().ModuleMaps ? &SuggestedModule : nullptr, /*SkipCache*/ true); d1494 2 a1495 4 FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, false, LookupFrom, LookupFromFile, CurDir, Callbacks ? &SearchPath : nullptr, a1691 1 const FileEntry *LookupFromFile = nullptr; a1694 6 } 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; d1702 1 a1702 2 return HandleIncludeDirective(HashLoc, IncludeNextTok, Lookup, LookupFromFile); d1728 1 a1728 1 return HandleIncludeDirective(HashLoc, ImportTok, nullptr, nullptr, true); d1749 1 a1749 1 HandleIncludeDirective(HashLoc, IncludeMacrosTok); a1856 46 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 if ((MacroName.is(tok::kw_extern) || MacroName.is(tok::kw_inline) || MacroName.is(tok::kw_static) || MacroName.is(tok::kw_const)) && MI->getNumTokens() == 0) { return true; } return false; } d1864 1 a1864 2 bool MacroShadowsKeyword; ReadMacroName(MacroNameTok, MU_Define, &MacroShadowsKeyword); a2040 4 if (MacroShadowsKeyword && !isConfigurationPattern(MacroNameTok, MI, getLangOpts())) { Diag(MacroNameTok, diag::warn_pp_macro_hides_keyword); } d2112 1 a2112 1 ReadMacroName(MacroNameTok, MU_Undef); @ 1.1.1.7 log @Import Clang 3.6RC1 r227398. @ text @d103 1 a103 50 /// \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) { const LangOptions &Lang = PP.getLangOpts(); StringRef Text = II->getName(); if (isReservedId(Text, Lang)) return MD_ReservedMacro; if (II->isKeyword(Lang)) return MD_KeywordDef; if (Lang.CPlusPlus11 && (Text.equals("override") || Text.equals("final"))) return MD_KeywordDef; return MD_NoWarn; } 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; } bool Preprocessor::CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef, bool *ShadowFlag) { d131 1 a131 1 if ((isDefineUndef != MU_Other) && II->getPPKeywordID() == tok::pp_defined) { d136 1 a136 1 if (isDefineUndef == MU_Undef && II->hasMacroDefinition() && a142 24 // If defining/undefining reserved identifier or a keyword, we need to issue // a warning. SourceLocation MacroNameLoc = MacroNameTok.getLocation(); if (ShadowFlag) *ShadowFlag = false; if (!SourceMgr.isInSystemHeader(MacroNameLoc) && (strcmp(SourceMgr.getBufferName(MacroNameLoc), "") != 0)) { 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); } d150 5 a154 8 /// 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. /// \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) { d160 1 a160 1 CodeComplete->CodeCompleteMacroName(isDefineUndef == MU_Define); d165 1 a165 1 if (!CheckMacroName(MacroNameTok, isDefineUndef, ShadowFlag)) a536 1 const FileEntry *FromFile, d544 2 a545 3 SmallVector, 16> Includers; if (!FromDir && !FromFile) { d550 10 a559 20 // 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. if (!FileEnt) { if (FID == SourceMgr.getMainFileID() && MainFileDir) Includers.push_back(std::make_pair(nullptr, MainFileDir)); else if ((FileEnt = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID()))) Includers.push_back(std::make_pair(FileEnt, FileMgr.getDirectory("."))); } else { Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir())); } d570 1 a570 1 Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir())); d575 1 a576 23 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, Includers, SearchPath, RelativePath, SuggestedModule, SkipCache)) { // 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. d691 1 a691 2 case tok::pp_pragma: Diag(Result, diag::err_embedded_directive) << II->getName(); d1171 1 a1171 1 ReadMacroName(MacroNameTok, MU_Undef); d1198 1 a1198 1 ReadMacroName(MacroNameTok, MU_Undef); a1352 1 const FileEntry *LookupFromFile, d1450 2 a1451 2 isAngled, LookupFrom, LookupFromFile, CurDir, Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr, d1465 8 a1472 7 File = LookupFile( FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled, LookupFrom, LookupFromFile, CurDir, nullptr, nullptr, HeaderInfo.getHeaderSearchOpts().ModuleMaps ? &SuggestedModule : nullptr, /*SkipCache*/ true); d1494 2 a1495 4 FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, false, LookupFrom, LookupFromFile, CurDir, Callbacks ? &SearchPath : nullptr, a1691 1 const FileEntry *LookupFromFile = nullptr; a1694 6 } 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; d1702 1 a1702 2 return HandleIncludeDirective(HashLoc, IncludeNextTok, Lookup, LookupFromFile); d1728 1 a1728 1 return HandleIncludeDirective(HashLoc, ImportTok, nullptr, nullptr, true); d1749 1 a1749 1 HandleIncludeDirective(HashLoc, IncludeMacrosTok); a1856 46 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 if ((MacroName.is(tok::kw_extern) || MacroName.is(tok::kw_inline) || MacroName.is(tok::kw_static) || MacroName.is(tok::kw_const)) && MI->getNumTokens() == 0) { return true; } return false; } d1864 1 a1864 2 bool MacroShadowsKeyword; ReadMacroName(MacroNameTok, MU_Define, &MacroShadowsKeyword); a2040 4 if (MacroShadowsKeyword && !isConfigurationPattern(MacroNameTok, MI, getLangOpts())) { Diag(MacroNameTok, diag::warn_pp_macro_hides_keyword); } d2112 1 a2112 1 ReadMacroName(MacroNameTok, MU_Undef); @ 1.1.1.8 log @Import Clang 3.8.0rc3 r261930. @ text @d65 9 a73 3 DefMacroDirective *Preprocessor::AllocateDefMacroDirective(MacroInfo *MI, SourceLocation Loc) { return new (BP) DefMacroDirective(MI, Loc); d77 8 a84 2 Preprocessor::AllocateUndefMacroDirective(SourceLocation UndefLoc) { return new (BP) UndefMacroDirective(UndefLoc); d185 5 a189 7 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); } d588 1 a588 1 Module *Preprocessor::getModuleForLocation(SourceLocation Loc) { d590 1 a590 1 if (SourceMgr.isInMainFile(Loc)) { d597 1 a597 1 FileID IDOfIncl = SourceMgr.getFileID(SourceMgr.getExpansionLoc(Loc)); a607 5 Module *Preprocessor::getModuleContainingLocation(SourceLocation Loc) { return HeaderInfo.getModuleMap().inferModuleFromLocation( FullSourceLoc(Loc, SourceMgr)); } a618 2 Module *RequestingModule = getModuleForLocation(FilenameLoc); d656 2 a657 1 if ((FileEnt = ISEntry.ThePPLexer->getFileEntry())) d672 2 a673 2 Includers, SearchPath, RelativePath, RequestingModule, SuggestedModule, SkipCache)) { d689 1 a689 1 RelativePath, RequestingModule, SuggestedModule, SkipCache); d693 1 a693 1 RequestingModule, FilenameLoc, Filename, FE); d702 1 a702 1 if ((CurFileEnt = CurPPLexer->getFileEntry())) { a704 1 RequestingModule, d708 1 a708 1 RequestingModule, FilenameLoc, Filename, FE); d717 2 a718 1 if ((CurFileEnt = ISEntry.ThePPLexer->getFileEntry())) { d721 1 a721 1 RequestingModule, SuggestedModule))) { d724 1 a724 1 RequestingModule, FilenameLoc, Filename, FE); d1236 1 a1236 1 StringRef Msg = StringRef(Message).ltrim(" "); d1293 1 a1293 1 MacroDirective *MD = getLocalMacroDirective(II); d1320 1 a1320 1 MacroDirective *MD = getLocalMacroDirective(II); a1446 2 // FIXME: Produce this as the current token directly, rather than // allocating a new token for it. a1455 45 /// \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> 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; switch (IncludeTok.getIdentifierInfo()->getPPKeywordID()) { case tok::pp_include: IncludeKind = 0; break; case tok::pp_import: IncludeKind = 1; break; case tok::pp_include_next: IncludeKind = 2; break; case tok::pp___include_macros: IncludeKind = 3; break; 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()); } d1494 1 a1494 1 Filename = FilenameBuffer; a1535 9 // 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(); } d1564 1 a1564 1 &SuggestedModule); d1566 2 a1567 2 if (!File) { if (Callbacks) { d1581 3 a1583 1 &SuggestedModule, /*SkipCache*/ true); d1587 10 d1598 1 d1610 2 a1611 1 &SuggestedModule); a1618 1 d1623 2 d1627 3 a1629 12 // 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() != getLangOpts().CurrentModule && d1631 1 a1631 24 getLangOpts().ImplementationOfModule) { // If this include corresponds to a module but that module is // unavailable, diagnose the situation and bail out. if (!SuggestedModule.getModule()->isAvailable()) { clang::Module::Requirement Requirement; clang::Module::UnresolvedHeaderDirective MissingHeader; 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; } d1642 7 a1648 3 // We only do this in Objective-C, where we have a module-import syntax. if (getLangOpts().ObjC2) diagnoseAutoModuleImport(*this, HashLoc, IncludeTok, Path, CharEnd); d1650 39 a1688 1 // Load the module to import its macros. We'll make the declarations d1690 4 a1693 5 // FIXME: Pass SuggestedModule in here rather than converting it to a path // and making the module loader convert it back again. ModuleLoadResult Imported = TheModuleLoader.loadModule( IncludeTok.getLocation(), Path, Module::Hidden, /*IsIncludeDirective=*/true); d1697 29 a1725 21 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); } d1729 7 d1738 8 a1745 7 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()); a1746 3 if (!File) return; a1754 3 // 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. d1757 1 a1757 4 if (ShouldEnter && !HeaderInfo.ShouldEnterIncludeFile(*this, File, isImport, SuggestedModule.getModule())) { ShouldEnter = false; a1759 12 } // If we don't need to enter the file, stop now. if (!ShouldEnter) { // If this is a module import, make it visible if needed. if (auto *M = SuggestedModule.getModule()) { makeModuleVisible(M, HashLoc); if (IncludeTok.getIdentifierInfo()->getPPKeywordID() != tok::pp___include_macros) EnterAnnotationToken(*this, HashLoc, End, tok::annot_module_include, M); } d1770 9 a1778 1 assert(FID.isValid() && "Expected valid file ID"); d1784 3 a1786 2 // Determine if we're switching to building a new submodule, and which one. if (auto *M = SuggestedModule.getModule()) { d1788 1 a1788 1 CurSubmodule = M; d1790 2 a1791 9 // Let the macro handling code know that any future macros are within // the new submodule. EnterSubmodule(M, HashLoc); // 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); d1921 1 a1921 1 MI->setArgumentList(Arguments, BP); d1955 1 a1955 1 MI->setArgumentList(Arguments, BP); d1971 1 a1971 1 MI->setArgumentList(Arguments, BP); d2015 7 a2021 3 return MacroName.isOneOf(tok::kw_extern, tok::kw_inline, tok::kw_static, tok::kw_const) && MI->getNumTokens() == 0; a2235 24 // 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; } d2293 3 a2295 3 // Okay, we have a valid identifier to undef. auto *II = MacroNameTok.getIdentifierInfo(); auto MD = getMacroDefinition(II); a2302 1 const MacroInfo *MI = MD.getMacroInfo(); d2347 2 a2348 2 auto MD = getMacroDefinition(MII); MacroInfo *MI = MD.getMacroInfo(); @ 1.1.1.8.2.1 log @Sync with HEAD @ text @d15 1 a15 1 #include "clang/Basic/CharInfo.h" a16 4 #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/Module.h" #include "clang/Basic/SourceLocation.h" a17 1 #include "clang/Basic/TokenKinds.h" d20 1 a24 2 #include "clang/Lex/ModuleMap.h" #include "clang/Lex/PPCallbacks.h" d26 1 a26 10 #include "clang/Lex/Preprocessor.h" #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" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/StringSwitch.h" #include "llvm/ADT/StringRef.h" #include "llvm/Support/AlignOf.h" d29 1 a29 7 #include #include #include #include #include #include d51 1 a51 1 static_assert(alignof(MacroInfo) >= sizeof(SubModuleID), a138 78 // 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. static const size_t MaxStdHeaderNameLen = 18u; if (Include.size() > MaxStdHeaderNameLen) return false; // Lowercase and normalize the search string. SmallString<32> LowerInclude{Include}; for (char &Ch : LowerInclude) { // In the ASCII range? if (static_cast(Ch) > 0x7f) 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(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); } d188 1 a188 1 (SourceMgr.getBufferName(MacroNameLoc) != "")) { d275 2 d304 1 a304 1 while (true) { d313 1 a313 1 d377 1 a377 1 size_t IdLen = DirectiveStr.size(); d500 2 a501 1 while (true) { d574 1 d579 16 a594 10 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(); } a595 6 // 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); a602 56 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; } d614 1 a614 2 Module *RequestingModule = getModuleForLocation(FilenameLoc); bool RequestingModuleIsModuleInterface = !SourceMgr.isInMainFile(FilenameLoc); a619 1 bool BuildSystemModule = false; d637 1 a637 1 if (FID == SourceMgr.getMainFileID() && MainFileDir) { d639 1 a639 2 BuildSystemModule = getCurrentModule()->IsSystem; } else if ((FileEnt = d650 2 a651 1 for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) { d685 1 a685 2 RelativePath, RequestingModule, SuggestedModule, SkipCache, BuildSystemModule); d689 1 a689 2 RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc, Filename, FE); d705 1 a705 2 RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc, Filename, FE); d711 2 a712 1 for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) { d720 1 a720 2 RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc, Filename, FE); d731 1 a742 1 a745 1 d852 1 a852 1 return HandleIncludeMacrosDirective(SavedHash.getLocation(), Result); d858 1 a858 1 return HandleUndefDirective(); d862 1 a862 1 return HandleLineDirective(); d891 1 a891 1 d896 1 a896 1 d899 1 a899 1 return HandleMacroPrivateDirective(); d910 1 a910 1 auto Toks = llvm::make_unique(2); d914 1 a914 1 d919 1 a919 1 d923 1 a923 1 EnterTokenStream(std::move(Toks), 2, false); d956 1 a956 1 d997 1 a997 1 void Preprocessor::HandleLineDirective() { d1007 1 a1007 1 d1090 1 a1090 1 d1213 1 d1232 1 a1232 1 StringRef Msg = StringRef(Message).ltrim(' '); d1279 1 a1279 1 d1290 1 a1290 1 d1296 1 a1296 1 d1303 1 a1303 1 void Preprocessor::HandleMacroPrivateDirective() { d1306 1 a1306 1 d1310 1 a1310 1 d1313 1 a1313 1 d1317 1 a1317 1 d1323 1 a1323 1 d1398 1 a1398 1 d1412 1 a1412 1 size_t PreAppendSize = FilenameBuffer.size(); d1445 1 a1445 1 auto Tok = llvm::make_unique(1); d1451 1 a1451 1 PP.EnterTokenStream(std::move(Tok), 1, true); d1463 1 a1463 1 for (size_t I = 0, N = Path.size(); I != N; ++I) { d1469 1 a1469 1 d1474 1 a1474 1 d1477 2 a1478 2 break; d1482 1 a1482 1 d1486 1 a1486 1 a1498 33 // 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 &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; } d1504 1 a1504 1 void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc, d1509 1 d1518 1 a1518 1 d1589 2 a1590 2 // 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 d1627 1 a1627 1 d1639 1 a1639 1 // If the file could not be located and it was included via angle d1652 2 a1653 2 Diag(FilenameTok, diag::err_pp_file_not_found_not_fatal) << Filename << d1660 1 a1660 2 Diag(FilenameTok, diag::err_pp_file_not_found) << Filename << FilenameRange; d1675 4 a1678 1 getLangOpts().CurrentModule) { a1680 2 // FIXME: Remove this; loadModule does the same check (but produces // slightly worse diagnostics). d1682 2 a1683 2 Module::Requirement Requirement; Module::UnresolvedHeaderDirective MissingHeader; d1714 1 a1714 1 d1730 1 a1730 1 // actual module containing it exists (because the umbrella header is a1732 3 } else if (Imported.isConfigMismatch()) { // On a configuration mismatch, enter the header textually. We still know // that it's part of the corresponding module. d1762 1 a1762 1 a1772 33 // 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 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); } } a1774 1 bool SkipHeader = false; a1776 1 getLangOpts().Modules, a1778 1 SkipHeader = true; a1786 8 // When building a pch, -fmodule-name tells the compiler to textually // include headers in the specified module. But it is possible that // ShouldEnter is false because we are skipping the header. In that // case, We are not importing the specified module. if (SkipHeader && getLangOpts().CompilingPCH && M->getTopLevelModuleName() == getLangOpts().CurrentModule) return; a1810 7 // When building a pch, -fmodule-name tells the compiler to textually // include headers in the specified module. We are not building the // specified module. if (getLangOpts().CompilingPCH && M->getTopLevelModuleName() == getLangOpts().CurrentModule) return; d1837 1 a1837 5 if (isInPrimaryFile() && LangOpts.IsHeaderFile) { // If the main file is a header, then it's either for PCH/AST generation, // or libclang opened it. Either way, handle it as a normal include below // and do not complain about include_next. } else if (isInPrimaryFile()) { d1866 1 a1866 1 // Read tokens until we get to the end of the directive. Note that the d1892 1 a1892 1 if (SourceMgr.getBufferName(Loc) != "") { d1921 1 a1921 1 while (true) { d1933 1 a1933 1 Diag(Tok, LangOpts.CPlusPlus11 ? d2150 1 d2158 1 a2158 1 if (!Tok.isOneOf(tok::hash, tok::hashat, tok::hashhash)) { d2179 1 d2183 1 a2183 1 d2218 1 a2218 2 Diag(Tok, diag::err_pp_stringize_not_parameter) << LastTok.is(tok::hashat); d2295 1 a2295 1 // Warn if defining "__LINE__" and other builtins, per C99 6.10.8/4 and d2331 1 a2331 1 void Preprocessor::HandleUndefDirective() { d2368 1 d2557 1 a2557 1 @ 1.1.1.9 log @Import Clang pre-4.0.0 r291444. @ text @d15 1 a15 1 #include "clang/Basic/CharInfo.h" a16 4 #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/Module.h" #include "clang/Basic/SourceLocation.h" a17 1 #include "clang/Basic/TokenKinds.h" d20 1 a24 2 #include "clang/Lex/ModuleMap.h" #include "clang/Lex/PPCallbacks.h" d26 1 a26 10 #include "clang/Lex/Preprocessor.h" #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" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/StringSwitch.h" #include "llvm/ADT/StringRef.h" #include "llvm/Support/AlignOf.h" d29 1 a29 7 #include #include #include #include #include #include d51 1 a51 1 static_assert(alignof(MacroInfo) >= sizeof(SubModuleID), a138 78 // 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. static const size_t MaxStdHeaderNameLen = 18u; if (Include.size() > MaxStdHeaderNameLen) return false; // Lowercase and normalize the search string. SmallString<32> LowerInclude{Include}; for (char &Ch : LowerInclude) { // In the ASCII range? if (static_cast(Ch) > 0x7f) 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(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); } d188 1 a188 1 (SourceMgr.getBufferName(MacroNameLoc) != "")) { d275 2 d304 1 a304 1 while (true) { d313 1 a313 1 d377 1 a377 1 size_t IdLen = DirectiveStr.size(); d500 2 a501 1 while (true) { d574 1 d579 16 a594 10 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(); } a595 6 // 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); a602 56 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; } d614 1 a614 2 Module *RequestingModule = getModuleForLocation(FilenameLoc); bool RequestingModuleIsModuleInterface = !SourceMgr.isInMainFile(FilenameLoc); a619 1 bool BuildSystemModule = false; d637 1 a637 1 if (FID == SourceMgr.getMainFileID() && MainFileDir) { d639 1 a639 2 BuildSystemModule = getCurrentModule()->IsSystem; } else if ((FileEnt = d650 2 a651 1 for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) { d685 1 a685 2 RelativePath, RequestingModule, SuggestedModule, SkipCache, BuildSystemModule); d689 1 a689 2 RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc, Filename, FE); d705 1 a705 2 RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc, Filename, FE); d711 2 a712 1 for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) { d720 1 a720 2 RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc, Filename, FE); d731 1 a742 1 a745 1 d852 1 a852 1 return HandleIncludeMacrosDirective(SavedHash.getLocation(), Result); d858 1 a858 1 return HandleUndefDirective(); d862 1 a862 1 return HandleLineDirective(); d891 1 a891 1 d896 1 a896 1 d899 1 a899 1 return HandleMacroPrivateDirective(); d910 1 a910 1 auto Toks = llvm::make_unique(2); d914 1 a914 1 d919 1 a919 1 d923 1 a923 1 EnterTokenStream(std::move(Toks), 2, false); d956 1 a956 1 d997 1 a997 1 void Preprocessor::HandleLineDirective() { d1007 1 a1007 1 d1090 1 a1090 1 d1213 1 d1232 1 a1232 1 StringRef Msg = StringRef(Message).ltrim(' '); d1279 1 a1279 1 d1290 1 a1290 1 d1296 1 a1296 1 d1303 1 a1303 1 void Preprocessor::HandleMacroPrivateDirective() { d1306 1 a1306 1 d1310 1 a1310 1 d1313 1 a1313 1 d1317 1 a1317 1 d1323 1 a1323 1 d1398 1 a1398 1 d1412 1 a1412 1 size_t PreAppendSize = FilenameBuffer.size(); d1445 1 a1445 1 auto Tok = llvm::make_unique(1); d1451 1 a1451 1 PP.EnterTokenStream(std::move(Tok), 1, true); d1463 1 a1463 1 for (size_t I = 0, N = Path.size(); I != N; ++I) { d1469 1 a1469 1 d1474 1 a1474 1 d1477 2 a1478 2 break; d1482 1 a1482 1 d1486 1 a1486 1 a1498 33 // 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 &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; } d1504 1 a1504 1 void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc, d1509 1 d1518 1 a1518 1 d1589 2 a1590 2 // 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 d1627 1 a1627 1 d1639 1 a1639 1 // If the file could not be located and it was included via angle d1652 2 a1653 2 Diag(FilenameTok, diag::err_pp_file_not_found_not_fatal) << Filename << d1660 1 a1660 2 Diag(FilenameTok, diag::err_pp_file_not_found) << Filename << FilenameRange; d1675 4 a1678 1 getLangOpts().CurrentModule) { a1680 2 // FIXME: Remove this; loadModule does the same check (but produces // slightly worse diagnostics). d1682 2 a1683 2 Module::Requirement Requirement; Module::UnresolvedHeaderDirective MissingHeader; d1714 1 a1714 1 d1730 1 a1730 1 // actual module containing it exists (because the umbrella header is a1732 3 } else if (Imported.isConfigMismatch()) { // On a configuration mismatch, enter the header textually. We still know // that it's part of the corresponding module. d1762 1 a1762 1 a1772 33 // 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 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); } } d1837 1 a1837 5 if (isInPrimaryFile() && LangOpts.IsHeaderFile) { // If the main file is a header, then it's either for PCH/AST generation, // or libclang opened it. Either way, handle it as a normal include below // and do not complain about include_next. } else if (isInPrimaryFile()) { d1866 1 a1866 1 // Read tokens until we get to the end of the directive. Note that the d1892 1 a1892 1 if (SourceMgr.getBufferName(Loc) != "") { d1921 1 a1921 1 while (true) { d1933 1 a1933 1 Diag(Tok, LangOpts.CPlusPlus11 ? d2150 1 d2158 1 a2158 1 if (!Tok.isOneOf(tok::hash, tok::hashat, tok::hashhash)) { d2179 1 d2183 1 a2183 1 d2218 1 a2218 2 Diag(Tok, diag::err_pp_stringize_not_parameter) << LastTok.is(tok::hashat); d2295 1 a2295 1 // Warn if defining "__LINE__" and other builtins, per C99 6.10.8/4 and d2331 1 a2331 1 void Preprocessor::HandleUndefDirective() { d2368 1 d2557 1 a2557 1 @ 1.1.1.9.2.1 log @Sync with HEAD @ text @a1998 1 bool SkipHeader = false; a2000 1 getLangOpts().Modules, a2002 1 SkipHeader = true; a2010 8 // When building a pch, -fmodule-name tells the compiler to textually // include headers in the specified module. But it is possible that // ShouldEnter is false because we are skipping the header. In that // case, We are not importing the specified module. if (SkipHeader && getLangOpts().CompilingPCH && M->getTopLevelModuleName() == getLangOpts().CurrentModule) return; a2034 7 // When building a pch, -fmodule-name tells the compiler to textually // include headers in the specified module. We are not building the // specified module. if (getLangOpts().CompilingPCH && M->getTopLevelModuleName() == getLangOpts().CurrentModule) return; @ 1.1.1.10 log @Import Clang 4.0RC1 r294123. @ text @a1998 1 bool SkipHeader = false; a2000 1 getLangOpts().Modules, a2002 1 SkipHeader = true; a2010 8 // When building a pch, -fmodule-name tells the compiler to textually // include headers in the specified module. But it is possible that // ShouldEnter is false because we are skipping the header. In that // case, We are not importing the specified module. if (SkipHeader && getLangOpts().CompilingPCH && M->getTopLevelModuleName() == getLangOpts().CurrentModule) return; a2034 7 // When building a pch, -fmodule-name tells the compiler to textually // include headers in the specified module. We are not building the // specified module. if (getLangOpts().CompilingPCH && M->getTopLevelModuleName() == getLangOpts().CurrentModule) return; @ 1.1.1.11 log @Import clang r309604 from branches/release_50 @ text @a32 1 #include "clang/Lex/PreprocessorOptions.h" d57 3 a59 2 MacroInfo *Preprocessor::AllocateMacroInfo(SourceLocation L) { auto *MIChain = new (BP) MacroInfoChain{L, MIChainHead}; d64 22 d245 9 a253 2 if (!II) return Diag(MacroNameTok, diag::err_pp_macro_not_identifier); a254 1 if (II->isCPlusPlusOperatorKeyword()) { d261 1 d264 1 d563 1 a563 1 const bool CondValue = EvaluateDirectiveExpression(IfNDefMacro).Conditional; d660 1 a660 1 bool ShouldEnter = EvaluateDirectiveExpression(IfNDefMacro).Conditional; d693 5 a699 1 Module *M, a700 2 assert(M && "no module to include"); d706 5 a721 2 if (!FE) break; d755 7 a761 3 SourceLocation FilenameLoc, StringRef Filename, bool isAngled, const DirectoryLookup *FromDir, const FileEntry *FromFile, const DirectoryLookup *&CurDir, SmallVectorImpl *SearchPath, d763 2 a764 1 ModuleMap::KnownHeader *SuggestedModule, bool *IsMapped, bool SkipCache) { d822 1 a822 1 SuggestedModule, /*IsMapped=*/nullptr, SkipCache)) { d838 1 a838 1 RelativePath, RequestingModule, SuggestedModule, IsMapped, SkipCache, d1209 1 a1209 10 // Take the file kind of the file containing the #line directive. #line // directives are often used for generated sources from the same codebase, so // the new file should generally be classified the same way as the current // file. This is visible in GCC's pre-processed output, which rewrites #line // to GNU line markers. SrcMgr::CharacteristicKind FileKind = SourceMgr.getFileCharacteristic(DigitTok.getLocation()); SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, false, false, FileKind); d1213 2 a1214 1 PPCallbacks::RenameFile, FileKind); d1220 1 a1220 1 SrcMgr::CharacteristicKind &FileKind, d1271 1 a1271 1 FileKind = SrcMgr::C_System; d1285 1 a1285 1 FileKind = SrcMgr::C_ExternCSystem; d1315 1 a1316 1 SrcMgr::CharacteristicKind FileKind = SrcMgr::C_User; d1320 3 a1322 4 if (StrTok.is(tok::eod)) { // Treat this like "#line NN", which doesn't change file characteristics. FileKind = SourceMgr.getFileCharacteristic(DigitTok.getLocation()); } else if (StrTok.isNot(tok::string_literal)) { d1341 2 a1342 1 if (ReadLineMarkerFlags(IsFileEntry, IsFileExit, FileKind, *this)) d1347 3 a1349 2 SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, IsFileEntry, IsFileExit, FileKind); d1360 5 d1596 3 a1598 3 void Preprocessor::EnterAnnotationToken(SourceRange Range, tok::TokenKind Kind, void *AnnotationVal) { d1604 2 a1605 2 Tok[0].setLocation(Range.getBegin()); Tok[0].setAnnotationEndLoc(Range.getEnd()); d1607 1 a1607 1 EnterTokenStream(std::move(Tok), 1, true); a1687 20 bool Preprocessor::checkModuleIsAvailable(const LangOptions &LangOpts, const TargetInfo &TargetInfo, DiagnosticsEngine &Diags, Module *M) { Module::Requirement Requirement; Module::UnresolvedHeaderDirective MissingHeader; if (M->isAvailable(LangOpts, TargetInfo, Requirement, MissingHeader)) return false; if (MissingHeader.FileNameLoc.isValid()) { Diags.Report(MissingHeader.FileNameLoc, diag::err_module_header_missing) << MissingHeader.IsUmbrella << MissingHeader.FileName; } else { // FIXME: Track the location at which the requirement was specified, and // use it here. Diags.Report(M->DefinitionLoc, diag::err_module_unavailable) << M->getFullModuleName() << Requirement.second << Requirement.first; } return true; } a1785 1 bool IsMapped = false; d1804 1 a1804 1 &SuggestedModule, &IsMapped); d1821 1 a1821 1 &SuggestedModule, &IsMapped, /*SkipCache*/ true); d1836 2 a1837 1 Callbacks ? &RelativePath : nullptr, &SuggestedModule, &IsMapped); a1858 3 if (PPOpts->SingleFileParseMode) ShouldEnter = false; d1862 1 a1862 1 if (ShouldEnter && File && SuggestedModule && getLangOpts().Modules && d1869 14 a1882 2 if (checkModuleIsAvailable(getLangOpts(), getTargetInfo(), getDiagnostics(), SuggestedModule.getModule())) { d1885 1 a1885 1 << SuggestedModule.getModule()->getTopLevelModuleName(); a1941 19 // The #included file will be considered to be a system header if either it is // in a system include directory, or if the #includer is a system include // header. SrcMgr::CharacteristicKind FileCharacter = SourceMgr.getFileCharacteristic(FilenameTok.getLocation()); if (File) FileCharacter = std::max(HeaderInfo.getFileDirFlavor(File), FileCharacter); // Ask HeaderInfo if we should enter this #include file. If not, #including // this file will have no effect. bool SkipHeader = false; if (ShouldEnter && File && !HeaderInfo.ShouldEnterIncludeFile(*this, File, isImport, getLangOpts().Modules, SuggestedModule.getModule())) { ShouldEnter = false; SkipHeader = true; } a1948 2 if (SkipHeader && !SuggestedModule.getModule()) Callbacks->FileSkipped(*File, FilenameTok, FileCharacter); d1954 7 d1967 1 a1967 1 !IsMapped && File && !File->tryGetRealPathName().empty(); a1978 1 bool isLeadingSeparator = llvm::sys::path::is_absolute(Name); d1980 1 a1980 4 if (isLeadingSeparator) isLeadingSeparator = false; else Path.append(Component); d1986 1 d1992 2 a1993 2 Diag(FilenameTok, DiagId) << Path << FixItHint::CreateReplacement(Range, Path); d1997 13 d2026 1 a2026 2 EnterAnnotationToken(SourceRange(HashLoc, End), tok::annot_module_include, M); d2053 2 a2054 2 assert(!CurLexerSubmodule && "should not have marked this as a module yet"); CurLexerSubmodule = M; d2058 1 a2058 1 EnterSubmodule(M, HashLoc, /*ForPragma*/false); d2064 1 a2064 1 EnterAnnotationToken(SourceRange(HashLoc, End), tok::annot_module_begin, M); d2086 1 a2086 1 } else if (CurLexerSubmodule) { d2160 1 a2160 1 /// ReadMacroParameterList - The ( starting an argument list of a macro d2164 1 a2164 1 bool Preprocessor::ReadMacroParameterList(MacroInfo *MI, Token &Tok) { d2198 1 a2198 1 MI->setParameterList(Arguments, BP); d2232 1 a2232 1 MI->setParameterList(Arguments, BP); d2248 1 a2248 1 MI->setParameterList(Arguments, BP); d2297 9 a2305 7 // ReadOptionalMacroParameterListAndBody - This consumes all (i.e. the // entire line) of the macro's tokens and adds them to MacroInfo, and while // doing so performs certain validity checks including (but not limited to): // - # (stringization) is followed by a macro parameter // // Returns a nullptr if an invalid sequence of tokens is encountered or returns // a pointer to a MacroInfo object. d2307 3 a2309 2 MacroInfo *Preprocessor::ReadOptionalMacroParameterListAndBody( const Token &MacroNameTok, const bool ImmediatelyAfterHeaderGuard) { d2312 5 d2318 1 a2318 1 MacroInfo *const MI = AllocateMacroInfo(MacroNameTok.getLocation()); d2340 1 a2340 1 if (ReadMacroParameterList(MI, LastTok)) { d2344 1 a2344 1 return nullptr; d2451 1 a2451 1 MI->getParameterNum(Tok.getIdentifierInfo()) == -1) { d2467 1 a2467 1 return nullptr; a2479 28 MI->setDefinitionEndLoc(LastTok.getLocation()); // Disable __VA_ARGS__ again. Ident__VA_ARGS__->setIsPoisoned(true); return MI; } /// HandleDefineDirective - Implements \#define. This consumes the entire macro /// line then lets the caller lex the next real token. void Preprocessor::HandleDefineDirective( Token &DefineTok, const bool ImmediatelyAfterHeaderGuard) { ++NumDefined; Token MacroNameTok; bool MacroShadowsKeyword; ReadMacroName(MacroNameTok, MU_Define, &MacroShadowsKeyword); // Error reading macro name? If so, diagnostic already issued. if (MacroNameTok.is(tok::eod)) return; // If we are supposed to keep comments in #defines, reenable comment saving // mode. if (CurLexer) CurLexer->SetCommentRetentionState(KeepMacroComments); MacroInfo *const MI = ReadOptionalMacroParameterListAndBody( MacroNameTok, ImmediatelyAfterHeaderGuard); if (!MI) return; d2484 5 a2488 1 } d2503 1 a2503 1 a2591 12 UndefMacroDirective *Undef = nullptr; // If the macro is not defined, this is a noop undef. if (const MacroInfo *MI = MD.getMacroInfo()) { if (!MI->isUsed() && MI->isWarnIfUnused()) Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used); if (MI->isWarnIfUnused()) WarnUnusedMacroLocs.erase(MI->getDefinitionLoc()); Undef = AllocateUndefMacroDirective(MacroNameTok.getLocation()); } d2596 6 a2601 1 Callbacks->MacroUndefined(MacroNameTok, MD, Undef); d2603 8 a2610 2 if (Undef) appendMacroDirective(II, Undef); d2670 1 a2670 7 if (PPOpts->SingleFileParseMode && !MI) { // In 'single-file-parse mode' undefined identifiers trigger parsing of all // the directive blocks. CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(), /*wasskip*/false, /*foundnonskip*/false, /*foundelse*/false); } else if (!MI == isIfndef) { d2692 1 a2692 2 const DirectiveEvalResult DER = EvaluateDirectiveExpression(IfNDefMacro); const bool ConditionalTrue = DER.Conditional; d2711 1 a2711 6 if (PPOpts->SingleFileParseMode && DER.IncludedUndefinedIds) { // In 'single-file-parse mode' undefined identifiers trigger parsing of all // the directive blocks. CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false, /*foundnonskip*/false, /*foundelse*/false); } else if (ConditionalTrue) { a2771 8 if (PPOpts->SingleFileParseMode && !CI.FoundNonSkip) { // In 'single-file-parse mode' undefined identifiers trigger parsing of all // the directive blocks. CurPPLexer->pushConditionalLevel(CI.IfLoc, /*wasskip*/false, /*foundnonskip*/false, /*foundelse*/true); return; } a2806 8 if (PPOpts->SingleFileParseMode && !CI.FoundNonSkip) { // In 'single-file-parse mode' undefined identifiers trigger parsing of all // the directive blocks. CurPPLexer->pushConditionalLevel(ElifToken.getLocation(), /*wasskip*/false, /*foundnonskip*/false, /*foundelse*/false); return; } @ 1.1.1.11.4.1 log @Sync with HEAD @ text @d11 1 a11 1 /// Implements # directive processing for the Preprocessor. a35 1 #include "clang/Lex/VariadicMacroSupport.h" d80 1 a80 1 /// Read and discard all tokens remaining on the current line until d90 1 a90 1 /// Enumerates possible cases of #define/#undef a reserved identifier. d97 1 a97 1 /// Checks if the specified identifier is reserved in the specified a116 19 // The -fmodule-name option tells the compiler to textually include headers in // the specified module, meaning clang won't build the specified module. This is // useful in a number of situations, for instance, when building a library that // vends a module map, one might want to avoid hitting intermediate build // products containig the the module map or avoid finding the system installed // modulemap for that library. static bool isForModuleBuilding(Module *M, StringRef CurrentModule, StringRef ModuleName) { StringRef TopLevelName = M->getTopLevelModuleName(); // When building framework Foo, we wanna make sure that Foo *and* Foo_Private // are textually included and no modules are built for both. if (M->getTopLevelModule()->IsFramework && CurrentModule == ModuleName && !CurrentModule.endswith("_Private") && TopLevelName.endswith("_Private")) TopLevelName = TopLevelName.drop_back(8); return TopLevelName == CurrentModule; } d279 1 a279 1 /// Lex and validate a macro name, which occurs after a d311 1 a311 1 /// Ensure that the next token is a tok::eod token. d352 1 a352 2 void Preprocessor::SkipExcludedConditionalBlock(SourceLocation HashTokenLoc, SourceLocation IfTokenLoc, d359 2 a360 5 if (PreambleConditionalStack.reachedEOFWhileSkipping()) PreambleConditionalStack.clearSkipInfo(); else CurPPLexer->pushConditionalLevel(IfTokenLoc, /*isSkipping*/ false, FoundNonSkipPortion, FoundElse); d383 9 a391 2 // We don't emit errors for unterminated conditionals here, // Lexer::LexEndOfFile can do that propertly. a392 3 if (PreambleConditionalStack.isRecording()) PreambleConditionalStack.SkipInfo.emplace( HashTokenLoc, IfTokenLoc, FoundNonSkipPortion, FoundElse, ElseLoc); d560 4 a563 6 // The last skipped range isn't actually skipped yet if it's truncated // by the end of the preamble; we'll resume parsing after the preamble. if (Callbacks && (Tok.isNot(tok::eof) || !isRecordingPreamble())) Callbacks->SourceRangeSkipped( SourceRange(HashTokenLoc, CurPPLexer->getSourceLocation()), Tok.getLocation()); a867 16 /// Process a directive while looking for the through header. /// Only #include (to check if it is the through header) and #define (to warn /// about macros that don't match the PCH) are handled. All other directives /// are completely discarded. void Preprocessor::HandleSkippedThroughHeaderDirective(Token &Result, SourceLocation HashLoc) { if (const IdentifierInfo *II = Result.getIdentifierInfo()) { if (II->getPPKeywordID() == tok::pp_include) return HandleIncludeDirective(HashLoc, Result); if (II->getPPKeywordID() == tok::pp_define) return HandleDefineDirective(Result, /*ImmediatelyAfterHeaderGuard=*/false); } DiscardUntilEndOfDirective(); } a928 3 if (SkippingUntilPCHThroughHeader) return HandleSkippedThroughHeaderDirective(Result, SavedHash.getLocation()); d951 1 a951 1 return HandleIfDirective(Result, SavedHash, ReadAnyTokensBeforeDirective); d953 1 a953 2 return HandleIfdefDirective(Result, SavedHash, false, true /*not valid for miopt*/); d955 1 a955 2 return HandleIfdefDirective(Result, SavedHash, true, ReadAnyTokensBeforeDirective); d957 1 a957 1 return HandleElifDirective(Result, SavedHash); d959 1 a959 1 return HandleElseDirective(Result, SavedHash); d1107 1 a1107 1 /// Handle a \#line directive: C99 6.10.4. d1343 1 a1343 1 // collapse multiple consecutive white space between tokens, but this isn't d1393 1 a1393 1 /// Handle a #public directive. d1420 1 a1420 1 /// Handle a #private directive. d1496 1 a1496 1 // Handle cases where the \#include name is expanded from a macro d1557 1 a1557 1 /// Push a token onto the token stream containing an annotation. d1572 1 a1572 1 /// Produce a diagnostic informing the user that a #include or similar d1655 1 a1655 3 Module *ShadowingModule = nullptr; if (M->isAvailable(LangOpts, TargetInfo, Requirement, MissingHeader, ShadowingModule)) a1660 4 } else if (ShadowingModule) { Diags.Report(M->DefinitionLoc, diag::err_module_shadowed) << M->Name; Diags.Report(ShadowingModule->DefinitionLoc, diag::note_previous_definition); d1779 1 a1779 1 #ifndef _WIN32 a1834 6 if (usingPCHWithThroughHeader() && SkippingUntilPCHThroughHeader) { if (isPCHThroughHeader(File)) SkippingUntilPCHThroughHeader = false; return; } d1848 2 a1849 3 !isForModuleBuilding(SuggestedModule.getModule(), getLangOpts().CurrentModule, getLangOpts().ModuleName)) { d1940 1 a1940 1 ShouldEnter ? nullptr : SuggestedModule.getModule(), FileCharacter); d1996 1 a1996 2 isForModuleBuilding(M, getLangOpts().CurrentModule, getLangOpts().ModuleName)) d2014 1 a2014 1 IncludePos = SourceMgr.getExpansionRange(IncludePos).getEnd(); a2023 9 if (M->getTopLevelModule()->ShadowingModule) { // We are building a submodule that belongs to a shadowed module. This // means we find header files in the shadowed module. Diag(M->DefinitionLoc, diag::err_module_build_shadowed_submodule) << M->getFullModuleName(); Diag(M->getTopLevelModule()->ShadowingModule->DefinitionLoc, diag::note_previous_definition); return; } d2028 1 a2028 2 isForModuleBuilding(M, getLangOpts().CurrentModule, getLangOpts().ModuleName)) d2138 2 a2139 2 /// ReadMacroParameterList - The ( starting a parameter list of a macro /// definition has just been read. Lex the rest of the parameters and the d2141 1 a2141 1 /// parsing the param list. d2143 1 a2143 1 SmallVector Parameters; d2149 2 a2150 2 // Found the end of the parameter list. if (Parameters.empty()) // #define FOO() d2173 2 a2174 2 // Add the __VA_ARGS__ identifier as a parameter. Parameters.push_back(Ident__VA_ARGS__); d2176 1 a2176 1 MI->setParameterList(Parameters, BP); d2191 1 a2191 1 // If this is already used as a parameter, it is used multiple times (e.g. d2193 2 a2194 2 if (std::find(Parameters.begin(), Parameters.end(), II) != Parameters.end()) { // C99 6.10.3p6 d2199 2 a2200 2 // Add the parameter to the macro info. Parameters.push_back(II); d2210 1 a2210 1 MI->setParameterList(Parameters, BP); d2226 1 a2226 1 MI->setParameterList(Parameters, BP); a2292 4 // Used to un-poison and then re-poison identifiers of the __VA_ARGS__ ilk // within their appropriate context. VariadicMacroScopeGuard VariadicMacroScopeGuard(*this); d2317 2 a2318 4 // If this is a definition of an ISO C/C++ variadic function-like macro (not // using the GNU named varargs extension) inform our variadic scope guard // which un-poisons and re-poisons certain identifiers (e.g. __VA_ARGS__) // allowed only within the definition of a variadic macro. d2320 5 a2324 3 if (MI->isC99Varargs()) { VariadicMacroScopeGuard.enterScope(); } a2369 3 VAOptDefinitionContext VAOCtx(*this); a2375 35 if (VAOCtx.isVAOptToken(Tok)) { // If we're already within a VAOPT, emit an error. if (VAOCtx.isInVAOpt()) { Diag(Tok, diag::err_pp_vaopt_nested_use); return nullptr; } // Ensure VAOPT is followed by a '(' . LexUnexpandedToken(Tok); if (Tok.isNot(tok::l_paren)) { Diag(Tok, diag::err_pp_missing_lparen_in_vaopt_use); return nullptr; } MI->AddTokenToBody(Tok); VAOCtx.sawVAOptFollowedByOpeningParens(Tok.getLocation()); LexUnexpandedToken(Tok); if (Tok.is(tok::hashhash)) { Diag(Tok, diag::err_vaopt_paste_at_start); return nullptr; } continue; } else if (VAOCtx.isInVAOpt()) { if (Tok.is(tok::r_paren)) { if (VAOCtx.sawClosingParen()) { const unsigned NumTokens = MI->getNumTokens(); assert(NumTokens >= 3 && "Must have seen at least __VA_OPT__( " "and a subsequent tok::r_paren"); if (MI->getReplacementToken(NumTokens - 2).is(tok::hashhash)) { Diag(Tok, diag::err_vaopt_paste_at_end); return nullptr; } } } else if (Tok.is(tok::l_paren)) { VAOCtx.sawOpeningParen(Tok.getLocation()); } } a2415 1 // Our Token is a stringization operator. d2419 3 a2421 4 // Check for a valid macro arg identifier or __VA_OPT__. if (!VAOCtx.isVAOptToken(Tok) && (Tok.getIdentifierInfo() == nullptr || MI->getParameterNum(Tok.getIdentifierInfo()) == -1)) { d2434 3 d2443 2 d2446 2 a2447 17 // If the token following '#' is VAOPT, let the next iteration handle it // and check it for correctness, otherwise add the token and prime the // loop with the next one. if (!VAOCtx.isVAOptToken(Tok)) { MI->AddTokenToBody(Tok); LastTok = Tok; // Get the next token of the macro. LexUnexpandedToken(Tok); } } if (VAOCtx.isInVAOpt()) { assert(Tok.is(tok::eod) && "Must be at End Of preprocessing Directive"); Diag(Tok, diag::err_pp_expected_after) << LastTok.getKind() << tok::r_paren; Diag(VAOCtx.getUnmatchedOpeningParenLoc(), diag::note_matching) << tok::l_paren; return nullptr; d2451 3 d2497 1 a2497 9 // When skipping just warn about macros that do not match. if (SkippingUntilPCHThroughHeader) { const MacroInfo *OtherMI = getMacroInfo(MacroNameTok.getIdentifierInfo()); if (!OtherMI || !MI->isIdenticalTo(*OtherMI, *this, /*Syntactic=*/LangOpts.MicrosoftExt)) Diag(MI->getDefinitionLoc(), diag::warn_pp_macro_def_mismatch_with_pch) << MacroNameTok.getIdentifierInfo(); return; } d2617 1 a2617 3 void Preprocessor::HandleIfdefDirective(Token &Result, const Token &HashToken, bool isIfndef, d2629 2 a2630 3 SkipExcludedConditionalBlock(HashToken.getLocation(), DirectiveTok.getLocation(), /*Foundnonskip*/ false, /*FoundElse*/ false); d2678 3 a2680 4 SkipExcludedConditionalBlock(HashToken.getLocation(), DirectiveTok.getLocation(), /*Foundnonskip*/ false, /*FoundElse*/ false); a2686 1 const Token &HashToken, d2724 2 a2725 3 SkipExcludedConditionalBlock(HashToken.getLocation(), IfToken.getLocation(), /*Foundnonskip*/ false, /*FoundElse*/ false); d2757 1 a2757 1 void Preprocessor::HandleElseDirective(Token &Result, const Token &HashToken) { d2788 2 a2789 3 SkipExcludedConditionalBlock(HashToken.getLocation(), CI.IfLoc, /*Foundnonskip*/ true, /*FoundElse*/ true, Result.getLocation()); d2794 1 a2794 2 void Preprocessor::HandleElifDirective(Token &ElifToken, const Token &HashToken) { d2831 3 a2833 3 SkipExcludedConditionalBlock( HashToken.getLocation(), CI.IfLoc, /*Foundnonskip*/ true, /*FoundElse*/ CI.FoundElse, ElifToken.getLocation()); @ 1.1.1.11.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.11.2.1 log @Sync with HEAD @ text @d11 1 a11 1 /// Implements # directive processing for the Preprocessor. a35 1 #include "clang/Lex/VariadicMacroSupport.h" d80 1 a80 1 /// Read and discard all tokens remaining on the current line until d90 1 a90 1 /// Enumerates possible cases of #define/#undef a reserved identifier. d97 1 a97 1 /// Checks if the specified identifier is reserved in the specified a116 19 // The -fmodule-name option tells the compiler to textually include headers in // the specified module, meaning clang won't build the specified module. This is // useful in a number of situations, for instance, when building a library that // vends a module map, one might want to avoid hitting intermediate build // products containig the the module map or avoid finding the system installed // modulemap for that library. static bool isForModuleBuilding(Module *M, StringRef CurrentModule, StringRef ModuleName) { StringRef TopLevelName = M->getTopLevelModuleName(); // When building framework Foo, we wanna make sure that Foo *and* Foo_Private // are textually included and no modules are built for both. if (M->getTopLevelModule()->IsFramework && CurrentModule == ModuleName && !CurrentModule.endswith("_Private") && TopLevelName.endswith("_Private")) TopLevelName = TopLevelName.drop_back(8); return TopLevelName == CurrentModule; } d279 1 a279 1 /// Lex and validate a macro name, which occurs after a d311 1 a311 1 /// Ensure that the next token is a tok::eod token. d352 1 a352 2 void Preprocessor::SkipExcludedConditionalBlock(SourceLocation HashTokenLoc, SourceLocation IfTokenLoc, d359 2 a360 5 if (PreambleConditionalStack.reachedEOFWhileSkipping()) PreambleConditionalStack.clearSkipInfo(); else CurPPLexer->pushConditionalLevel(IfTokenLoc, /*isSkipping*/ false, FoundNonSkipPortion, FoundElse); d383 9 a391 2 // We don't emit errors for unterminated conditionals here, // Lexer::LexEndOfFile can do that propertly. a392 3 if (PreambleConditionalStack.isRecording()) PreambleConditionalStack.SkipInfo.emplace( HashTokenLoc, IfTokenLoc, FoundNonSkipPortion, FoundElse, ElseLoc); d560 4 a563 6 // The last skipped range isn't actually skipped yet if it's truncated // by the end of the preamble; we'll resume parsing after the preamble. if (Callbacks && (Tok.isNot(tok::eof) || !isRecordingPreamble())) Callbacks->SourceRangeSkipped( SourceRange(HashTokenLoc, CurPPLexer->getSourceLocation()), Tok.getLocation()); a867 16 /// Process a directive while looking for the through header. /// Only #include (to check if it is the through header) and #define (to warn /// about macros that don't match the PCH) are handled. All other directives /// are completely discarded. void Preprocessor::HandleSkippedThroughHeaderDirective(Token &Result, SourceLocation HashLoc) { if (const IdentifierInfo *II = Result.getIdentifierInfo()) { if (II->getPPKeywordID() == tok::pp_include) return HandleIncludeDirective(HashLoc, Result); if (II->getPPKeywordID() == tok::pp_define) return HandleDefineDirective(Result, /*ImmediatelyAfterHeaderGuard=*/false); } DiscardUntilEndOfDirective(); } a928 3 if (SkippingUntilPCHThroughHeader) return HandleSkippedThroughHeaderDirective(Result, SavedHash.getLocation()); d951 1 a951 1 return HandleIfDirective(Result, SavedHash, ReadAnyTokensBeforeDirective); d953 1 a953 2 return HandleIfdefDirective(Result, SavedHash, false, true /*not valid for miopt*/); d955 1 a955 2 return HandleIfdefDirective(Result, SavedHash, true, ReadAnyTokensBeforeDirective); d957 1 a957 1 return HandleElifDirective(Result, SavedHash); d959 1 a959 1 return HandleElseDirective(Result, SavedHash); d1107 1 a1107 1 /// Handle a \#line directive: C99 6.10.4. d1343 1 a1343 1 // collapse multiple consecutive white space between tokens, but this isn't d1393 1 a1393 1 /// Handle a #public directive. d1420 1 a1420 1 /// Handle a #private directive. d1496 1 a1496 1 // Handle cases where the \#include name is expanded from a macro d1557 1 a1557 1 /// Push a token onto the token stream containing an annotation. d1572 1 a1572 1 /// Produce a diagnostic informing the user that a #include or similar d1655 1 a1655 3 Module *ShadowingModule = nullptr; if (M->isAvailable(LangOpts, TargetInfo, Requirement, MissingHeader, ShadowingModule)) a1660 4 } else if (ShadowingModule) { Diags.Report(M->DefinitionLoc, diag::err_module_shadowed) << M->Name; Diags.Report(ShadowingModule->DefinitionLoc, diag::note_previous_definition); d1779 1 a1779 1 #ifndef _WIN32 a1834 6 if (usingPCHWithThroughHeader() && SkippingUntilPCHThroughHeader) { if (isPCHThroughHeader(File)) SkippingUntilPCHThroughHeader = false; return; } d1848 2 a1849 3 !isForModuleBuilding(SuggestedModule.getModule(), getLangOpts().CurrentModule, getLangOpts().ModuleName)) { d1940 1 a1940 1 ShouldEnter ? nullptr : SuggestedModule.getModule(), FileCharacter); d1996 1 a1996 2 isForModuleBuilding(M, getLangOpts().CurrentModule, getLangOpts().ModuleName)) d2014 1 a2014 1 IncludePos = SourceMgr.getExpansionRange(IncludePos).getEnd(); a2023 9 if (M->getTopLevelModule()->ShadowingModule) { // We are building a submodule that belongs to a shadowed module. This // means we find header files in the shadowed module. Diag(M->DefinitionLoc, diag::err_module_build_shadowed_submodule) << M->getFullModuleName(); Diag(M->getTopLevelModule()->ShadowingModule->DefinitionLoc, diag::note_previous_definition); return; } d2028 1 a2028 2 isForModuleBuilding(M, getLangOpts().CurrentModule, getLangOpts().ModuleName)) d2138 2 a2139 2 /// ReadMacroParameterList - The ( starting a parameter list of a macro /// definition has just been read. Lex the rest of the parameters and the d2141 1 a2141 1 /// parsing the param list. d2143 1 a2143 1 SmallVector Parameters; d2149 2 a2150 2 // Found the end of the parameter list. if (Parameters.empty()) // #define FOO() d2173 2 a2174 2 // Add the __VA_ARGS__ identifier as a parameter. Parameters.push_back(Ident__VA_ARGS__); d2176 1 a2176 1 MI->setParameterList(Parameters, BP); d2191 1 a2191 1 // If this is already used as a parameter, it is used multiple times (e.g. d2193 2 a2194 2 if (std::find(Parameters.begin(), Parameters.end(), II) != Parameters.end()) { // C99 6.10.3p6 d2199 2 a2200 2 // Add the parameter to the macro info. Parameters.push_back(II); d2210 1 a2210 1 MI->setParameterList(Parameters, BP); d2226 1 a2226 1 MI->setParameterList(Parameters, BP); a2292 4 // Used to un-poison and then re-poison identifiers of the __VA_ARGS__ ilk // within their appropriate context. VariadicMacroScopeGuard VariadicMacroScopeGuard(*this); d2317 2 a2318 4 // If this is a definition of an ISO C/C++ variadic function-like macro (not // using the GNU named varargs extension) inform our variadic scope guard // which un-poisons and re-poisons certain identifiers (e.g. __VA_ARGS__) // allowed only within the definition of a variadic macro. d2320 5 a2324 3 if (MI->isC99Varargs()) { VariadicMacroScopeGuard.enterScope(); } a2369 3 VAOptDefinitionContext VAOCtx(*this); a2375 35 if (VAOCtx.isVAOptToken(Tok)) { // If we're already within a VAOPT, emit an error. if (VAOCtx.isInVAOpt()) { Diag(Tok, diag::err_pp_vaopt_nested_use); return nullptr; } // Ensure VAOPT is followed by a '(' . LexUnexpandedToken(Tok); if (Tok.isNot(tok::l_paren)) { Diag(Tok, diag::err_pp_missing_lparen_in_vaopt_use); return nullptr; } MI->AddTokenToBody(Tok); VAOCtx.sawVAOptFollowedByOpeningParens(Tok.getLocation()); LexUnexpandedToken(Tok); if (Tok.is(tok::hashhash)) { Diag(Tok, diag::err_vaopt_paste_at_start); return nullptr; } continue; } else if (VAOCtx.isInVAOpt()) { if (Tok.is(tok::r_paren)) { if (VAOCtx.sawClosingParen()) { const unsigned NumTokens = MI->getNumTokens(); assert(NumTokens >= 3 && "Must have seen at least __VA_OPT__( " "and a subsequent tok::r_paren"); if (MI->getReplacementToken(NumTokens - 2).is(tok::hashhash)) { Diag(Tok, diag::err_vaopt_paste_at_end); return nullptr; } } } else if (Tok.is(tok::l_paren)) { VAOCtx.sawOpeningParen(Tok.getLocation()); } } a2415 1 // Our Token is a stringization operator. d2419 3 a2421 4 // Check for a valid macro arg identifier or __VA_OPT__. if (!VAOCtx.isVAOptToken(Tok) && (Tok.getIdentifierInfo() == nullptr || MI->getParameterNum(Tok.getIdentifierInfo()) == -1)) { d2434 3 d2443 2 d2446 2 a2447 17 // If the token following '#' is VAOPT, let the next iteration handle it // and check it for correctness, otherwise add the token and prime the // loop with the next one. if (!VAOCtx.isVAOptToken(Tok)) { MI->AddTokenToBody(Tok); LastTok = Tok; // Get the next token of the macro. LexUnexpandedToken(Tok); } } if (VAOCtx.isInVAOpt()) { assert(Tok.is(tok::eod) && "Must be at End Of preprocessing Directive"); Diag(Tok, diag::err_pp_expected_after) << LastTok.getKind() << tok::r_paren; Diag(VAOCtx.getUnmatchedOpeningParenLoc(), diag::note_matching) << tok::l_paren; return nullptr; d2451 3 d2497 1 a2497 9 // When skipping just warn about macros that do not match. if (SkippingUntilPCHThroughHeader) { const MacroInfo *OtherMI = getMacroInfo(MacroNameTok.getIdentifierInfo()); if (!OtherMI || !MI->isIdenticalTo(*OtherMI, *this, /*Syntactic=*/LangOpts.MicrosoftExt)) Diag(MI->getDefinitionLoc(), diag::warn_pp_macro_def_mismatch_with_pch) << MacroNameTok.getIdentifierInfo(); return; } d2617 1 a2617 3 void Preprocessor::HandleIfdefDirective(Token &Result, const Token &HashToken, bool isIfndef, d2629 2 a2630 3 SkipExcludedConditionalBlock(HashToken.getLocation(), DirectiveTok.getLocation(), /*Foundnonskip*/ false, /*FoundElse*/ false); d2678 3 a2680 4 SkipExcludedConditionalBlock(HashToken.getLocation(), DirectiveTok.getLocation(), /*Foundnonskip*/ false, /*FoundElse*/ false); a2686 1 const Token &HashToken, d2724 2 a2725 3 SkipExcludedConditionalBlock(HashToken.getLocation(), IfToken.getLocation(), /*Foundnonskip*/ false, /*FoundElse*/ false); d2757 1 a2757 1 void Preprocessor::HandleElseDirective(Token &Result, const Token &HashToken) { d2788 2 a2789 3 SkipExcludedConditionalBlock(HashToken.getLocation(), CI.IfLoc, /*Foundnonskip*/ true, /*FoundElse*/ true, Result.getLocation()); d2794 1 a2794 2 void Preprocessor::HandleElifDirective(Token &ElifToken, const Token &HashToken) { d2831 3 a2833 3 SkipExcludedConditionalBlock( HashToken.getLocation(), CI.IfLoc, /*Foundnonskip*/ true, /*FoundElse*/ CI.FoundElse, ElifToken.getLocation()); @ 1.1.1.12 log @Import clang r337282 from trunk @ text @d11 1 a11 1 /// Implements # directive processing for the Preprocessor. a35 1 #include "clang/Lex/VariadicMacroSupport.h" d80 1 a80 1 /// Read and discard all tokens remaining on the current line until d90 1 a90 1 /// Enumerates possible cases of #define/#undef a reserved identifier. d97 1 a97 1 /// Checks if the specified identifier is reserved in the specified a116 19 // The -fmodule-name option tells the compiler to textually include headers in // the specified module, meaning clang won't build the specified module. This is // useful in a number of situations, for instance, when building a library that // vends a module map, one might want to avoid hitting intermediate build // products containig the the module map or avoid finding the system installed // modulemap for that library. static bool isForModuleBuilding(Module *M, StringRef CurrentModule, StringRef ModuleName) { StringRef TopLevelName = M->getTopLevelModuleName(); // When building framework Foo, we wanna make sure that Foo *and* Foo_Private // are textually included and no modules are built for both. if (M->getTopLevelModule()->IsFramework && CurrentModule == ModuleName && !CurrentModule.endswith("_Private") && TopLevelName.endswith("_Private")) TopLevelName = TopLevelName.drop_back(8); return TopLevelName == CurrentModule; } d279 1 a279 1 /// Lex and validate a macro name, which occurs after a d311 1 a311 1 /// Ensure that the next token is a tok::eod token. d352 1 a352 2 void Preprocessor::SkipExcludedConditionalBlock(SourceLocation HashTokenLoc, SourceLocation IfTokenLoc, d359 2 a360 5 if (PreambleConditionalStack.reachedEOFWhileSkipping()) PreambleConditionalStack.clearSkipInfo(); else CurPPLexer->pushConditionalLevel(IfTokenLoc, /*isSkipping*/ false, FoundNonSkipPortion, FoundElse); d383 9 a391 2 // We don't emit errors for unterminated conditionals here, // Lexer::LexEndOfFile can do that propertly. a392 3 if (PreambleConditionalStack.isRecording()) PreambleConditionalStack.SkipInfo.emplace( HashTokenLoc, IfTokenLoc, FoundNonSkipPortion, FoundElse, ElseLoc); d560 4 a563 6 // The last skipped range isn't actually skipped yet if it's truncated // by the end of the preamble; we'll resume parsing after the preamble. if (Callbacks && (Tok.isNot(tok::eof) || !isRecordingPreamble())) Callbacks->SourceRangeSkipped( SourceRange(HashTokenLoc, CurPPLexer->getSourceLocation()), Tok.getLocation()); a867 16 /// Process a directive while looking for the through header. /// Only #include (to check if it is the through header) and #define (to warn /// about macros that don't match the PCH) are handled. All other directives /// are completely discarded. void Preprocessor::HandleSkippedThroughHeaderDirective(Token &Result, SourceLocation HashLoc) { if (const IdentifierInfo *II = Result.getIdentifierInfo()) { if (II->getPPKeywordID() == tok::pp_include) return HandleIncludeDirective(HashLoc, Result); if (II->getPPKeywordID() == tok::pp_define) return HandleDefineDirective(Result, /*ImmediatelyAfterHeaderGuard=*/false); } DiscardUntilEndOfDirective(); } a928 3 if (SkippingUntilPCHThroughHeader) return HandleSkippedThroughHeaderDirective(Result, SavedHash.getLocation()); d951 1 a951 1 return HandleIfDirective(Result, SavedHash, ReadAnyTokensBeforeDirective); d953 1 a953 2 return HandleIfdefDirective(Result, SavedHash, false, true /*not valid for miopt*/); d955 1 a955 2 return HandleIfdefDirective(Result, SavedHash, true, ReadAnyTokensBeforeDirective); d957 1 a957 1 return HandleElifDirective(Result, SavedHash); d959 1 a959 1 return HandleElseDirective(Result, SavedHash); d1107 1 a1107 1 /// Handle a \#line directive: C99 6.10.4. d1343 1 a1343 1 // collapse multiple consecutive white space between tokens, but this isn't d1393 1 a1393 1 /// Handle a #public directive. d1420 1 a1420 1 /// Handle a #private directive. d1496 1 a1496 1 // Handle cases where the \#include name is expanded from a macro d1557 1 a1557 1 /// Push a token onto the token stream containing an annotation. d1572 1 a1572 1 /// Produce a diagnostic informing the user that a #include or similar d1655 1 a1655 3 Module *ShadowingModule = nullptr; if (M->isAvailable(LangOpts, TargetInfo, Requirement, MissingHeader, ShadowingModule)) a1660 4 } else if (ShadowingModule) { Diags.Report(M->DefinitionLoc, diag::err_module_shadowed) << M->Name; Diags.Report(ShadowingModule->DefinitionLoc, diag::note_previous_definition); d1779 1 a1779 1 #ifndef _WIN32 a1834 6 if (usingPCHWithThroughHeader() && SkippingUntilPCHThroughHeader) { if (isPCHThroughHeader(File)) SkippingUntilPCHThroughHeader = false; return; } d1848 2 a1849 3 !isForModuleBuilding(SuggestedModule.getModule(), getLangOpts().CurrentModule, getLangOpts().ModuleName)) { d1940 1 a1940 1 ShouldEnter ? nullptr : SuggestedModule.getModule(), FileCharacter); d1996 1 a1996 2 isForModuleBuilding(M, getLangOpts().CurrentModule, getLangOpts().ModuleName)) d2014 1 a2014 1 IncludePos = SourceMgr.getExpansionRange(IncludePos).getEnd(); a2023 9 if (M->getTopLevelModule()->ShadowingModule) { // We are building a submodule that belongs to a shadowed module. This // means we find header files in the shadowed module. Diag(M->DefinitionLoc, diag::err_module_build_shadowed_submodule) << M->getFullModuleName(); Diag(M->getTopLevelModule()->ShadowingModule->DefinitionLoc, diag::note_previous_definition); return; } d2028 1 a2028 2 isForModuleBuilding(M, getLangOpts().CurrentModule, getLangOpts().ModuleName)) d2138 2 a2139 2 /// ReadMacroParameterList - The ( starting a parameter list of a macro /// definition has just been read. Lex the rest of the parameters and the d2141 1 a2141 1 /// parsing the param list. d2143 1 a2143 1 SmallVector Parameters; d2149 2 a2150 2 // Found the end of the parameter list. if (Parameters.empty()) // #define FOO() d2173 2 a2174 2 // Add the __VA_ARGS__ identifier as a parameter. Parameters.push_back(Ident__VA_ARGS__); d2176 1 a2176 1 MI->setParameterList(Parameters, BP); d2191 1 a2191 1 // If this is already used as a parameter, it is used multiple times (e.g. d2193 2 a2194 2 if (std::find(Parameters.begin(), Parameters.end(), II) != Parameters.end()) { // C99 6.10.3p6 d2199 2 a2200 2 // Add the parameter to the macro info. Parameters.push_back(II); d2210 1 a2210 1 MI->setParameterList(Parameters, BP); d2226 1 a2226 1 MI->setParameterList(Parameters, BP); a2292 4 // Used to un-poison and then re-poison identifiers of the __VA_ARGS__ ilk // within their appropriate context. VariadicMacroScopeGuard VariadicMacroScopeGuard(*this); d2317 2 a2318 4 // If this is a definition of an ISO C/C++ variadic function-like macro (not // using the GNU named varargs extension) inform our variadic scope guard // which un-poisons and re-poisons certain identifiers (e.g. __VA_ARGS__) // allowed only within the definition of a variadic macro. d2320 5 a2324 3 if (MI->isC99Varargs()) { VariadicMacroScopeGuard.enterScope(); } a2369 3 VAOptDefinitionContext VAOCtx(*this); a2375 35 if (VAOCtx.isVAOptToken(Tok)) { // If we're already within a VAOPT, emit an error. if (VAOCtx.isInVAOpt()) { Diag(Tok, diag::err_pp_vaopt_nested_use); return nullptr; } // Ensure VAOPT is followed by a '(' . LexUnexpandedToken(Tok); if (Tok.isNot(tok::l_paren)) { Diag(Tok, diag::err_pp_missing_lparen_in_vaopt_use); return nullptr; } MI->AddTokenToBody(Tok); VAOCtx.sawVAOptFollowedByOpeningParens(Tok.getLocation()); LexUnexpandedToken(Tok); if (Tok.is(tok::hashhash)) { Diag(Tok, diag::err_vaopt_paste_at_start); return nullptr; } continue; } else if (VAOCtx.isInVAOpt()) { if (Tok.is(tok::r_paren)) { if (VAOCtx.sawClosingParen()) { const unsigned NumTokens = MI->getNumTokens(); assert(NumTokens >= 3 && "Must have seen at least __VA_OPT__( " "and a subsequent tok::r_paren"); if (MI->getReplacementToken(NumTokens - 2).is(tok::hashhash)) { Diag(Tok, diag::err_vaopt_paste_at_end); return nullptr; } } } else if (Tok.is(tok::l_paren)) { VAOCtx.sawOpeningParen(Tok.getLocation()); } } a2415 1 // Our Token is a stringization operator. d2419 3 a2421 4 // Check for a valid macro arg identifier or __VA_OPT__. if (!VAOCtx.isVAOptToken(Tok) && (Tok.getIdentifierInfo() == nullptr || MI->getParameterNum(Tok.getIdentifierInfo()) == -1)) { d2434 3 d2443 2 d2446 2 a2447 17 // If the token following '#' is VAOPT, let the next iteration handle it // and check it for correctness, otherwise add the token and prime the // loop with the next one. if (!VAOCtx.isVAOptToken(Tok)) { MI->AddTokenToBody(Tok); LastTok = Tok; // Get the next token of the macro. LexUnexpandedToken(Tok); } } if (VAOCtx.isInVAOpt()) { assert(Tok.is(tok::eod) && "Must be at End Of preprocessing Directive"); Diag(Tok, diag::err_pp_expected_after) << LastTok.getKind() << tok::r_paren; Diag(VAOCtx.getUnmatchedOpeningParenLoc(), diag::note_matching) << tok::l_paren; return nullptr; d2451 3 d2497 1 a2497 9 // When skipping just warn about macros that do not match. if (SkippingUntilPCHThroughHeader) { const MacroInfo *OtherMI = getMacroInfo(MacroNameTok.getIdentifierInfo()); if (!OtherMI || !MI->isIdenticalTo(*OtherMI, *this, /*Syntactic=*/LangOpts.MicrosoftExt)) Diag(MI->getDefinitionLoc(), diag::warn_pp_macro_def_mismatch_with_pch) << MacroNameTok.getIdentifierInfo(); return; } d2617 1 a2617 3 void Preprocessor::HandleIfdefDirective(Token &Result, const Token &HashToken, bool isIfndef, d2629 2 a2630 3 SkipExcludedConditionalBlock(HashToken.getLocation(), DirectiveTok.getLocation(), /*Foundnonskip*/ false, /*FoundElse*/ false); d2678 3 a2680 4 SkipExcludedConditionalBlock(HashToken.getLocation(), DirectiveTok.getLocation(), /*Foundnonskip*/ false, /*FoundElse*/ false); a2686 1 const Token &HashToken, d2724 2 a2725 3 SkipExcludedConditionalBlock(HashToken.getLocation(), IfToken.getLocation(), /*Foundnonskip*/ false, /*FoundElse*/ false); d2757 1 a2757 1 void Preprocessor::HandleElseDirective(Token &Result, const Token &HashToken) { d2788 2 a2789 3 SkipExcludedConditionalBlock(HashToken.getLocation(), CI.IfLoc, /*Foundnonskip*/ true, /*FoundElse*/ true, Result.getLocation()); d2794 1 a2794 2 void Preprocessor::HandleElifDirective(Token &ElifToken, const Token &HashToken) { d2831 3 a2833 3 SkipExcludedConditionalBlock( HashToken.getLocation(), CI.IfLoc, /*Foundnonskip*/ true, /*FoundElse*/ CI.FoundElse, ElifToken.getLocation()); @ 1.1.1.13 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.6.4.1 log @file PPDirectives.cpp was added on branch tls-maxphys on 2014-08-19 23:47:29 +0000 @ text @d1 2343 @ 1.1.1.6.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 2343 //===--- PPDirectives.cpp - Directive Handling for Preprocessor -----------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// /// /// \file /// \brief Implements # directive processing for the Preprocessor. /// //===----------------------------------------------------------------------===// #include "clang/Lex/Preprocessor.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/SourceManager.h" #include "clang/Lex/CodeCompletionHandler.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/HeaderSearchOptions.h" #include "clang/Lex/LexDiagnostic.h" #include "clang/Lex/LiteralSupport.h" #include "clang/Lex/MacroInfo.h" #include "clang/Lex/ModuleLoader.h" #include "clang/Lex/Pragma.h" #include "llvm/ADT/APInt.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/Path.h" #include "llvm/Support/SaveAndRestore.h" using namespace clang; //===----------------------------------------------------------------------===// // Utility Methods for Preprocessor Directive Handling. //===----------------------------------------------------------------------===// MacroInfo *Preprocessor::AllocateMacroInfo() { MacroInfoChain *MIChain = BP.Allocate(); MIChain->Next = MIChainHead; MIChainHead = MIChain; return &MIChain->MI; } MacroInfo *Preprocessor::AllocateMacroInfo(SourceLocation L) { MacroInfo *MI = AllocateMacroInfo(); new (MI) MacroInfo(L); return MI; } MacroInfo *Preprocessor::AllocateDeserializedMacroInfo(SourceLocation L, unsigned SubModuleID) { static_assert(llvm::AlignOf::Alignment >= sizeof(SubModuleID), "alignment for MacroInfo is less than the ID"); DeserializedMacroInfoChain *MIChain = BP.Allocate(); MIChain->Next = DeserialMIChainHead; DeserialMIChainHead = MIChain; MacroInfo *MI = &MIChain->MI; new (MI) MacroInfo(L); MI->FromASTFile = true; MI->setOwningModuleID(SubModuleID); return MI; } DefMacroDirective * Preprocessor::AllocateDefMacroDirective(MacroInfo *MI, SourceLocation Loc, unsigned ImportedFromModuleID, ArrayRef Overrides) { unsigned NumExtra = (ImportedFromModuleID ? 1 : 0) + Overrides.size(); return new (BP.Allocate(sizeof(DefMacroDirective) + sizeof(unsigned) * NumExtra, llvm::alignOf())) DefMacroDirective(MI, Loc, ImportedFromModuleID, Overrides); } UndefMacroDirective * Preprocessor::AllocateUndefMacroDirective(SourceLocation UndefLoc, unsigned ImportedFromModuleID, ArrayRef Overrides) { unsigned NumExtra = (ImportedFromModuleID ? 1 : 0) + Overrides.size(); return new (BP.Allocate(sizeof(UndefMacroDirective) + sizeof(unsigned) * NumExtra, llvm::alignOf())) UndefMacroDirective(UndefLoc, ImportedFromModuleID, Overrides); } VisibilityMacroDirective * Preprocessor::AllocateVisibilityMacroDirective(SourceLocation Loc, bool isPublic) { return new (BP) VisibilityMacroDirective(Loc, isPublic); } /// \brief Read and discard all tokens remaining on the current line until /// the tok::eod token is found. void Preprocessor::DiscardUntilEndOfDirective() { Token Tmp; do { LexUnexpandedToken(Tmp); assert(Tmp.isNot(tok::eof) && "EOF seen while discarding directive tokens"); } while (Tmp.isNot(tok::eod)); } bool Preprocessor::CheckMacroName(Token &MacroNameTok, char isDefineUndef) { // Missing macro name? if (MacroNameTok.is(tok::eod)) return Diag(MacroNameTok, diag::err_pp_missing_macro_name); IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); if (!II) { bool Invalid = false; std::string Spelling = getSpelling(MacroNameTok, &Invalid); if (Invalid) return Diag(MacroNameTok, diag::err_pp_macro_not_identifier); II = getIdentifierInfo(Spelling); if (!II->isCPlusPlusOperatorKeyword()) return Diag(MacroNameTok, diag::err_pp_macro_not_identifier); // 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(); // Allow #defining |and| and friends for Microsoft compatibility or // recovery when legacy C headers are included in C++. MacroNameTok.setIdentifierInfo(II); } if (isDefineUndef && II->getPPKeywordID() == tok::pp_defined) { // Error if defining "defined": C99 6.10.8/4, C++ [cpp.predefined]p4. return Diag(MacroNameTok, diag::err_defined_macro_name); } if (isDefineUndef == 2 && II->hasMacroDefinition() && getMacroInfo(II)->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); } // Okay, we got a good identifier. return false; } /// \brief Lex and validate a macro name, which occurs after a /// \#define or \#undef. /// /// This sets the token kind to eod and discards the rest /// of the macro line if the macro name is invalid. \p isDefineUndef is 1 if /// this is due to a a \#define, 2 if \#undef directive, 0 if it is something /// else (e.g. \#ifdef). void Preprocessor::ReadMacroName(Token &MacroNameTok, char isDefineUndef) { // Read the token, don't allow macro expansion on it. LexUnexpandedToken(MacroNameTok); if (MacroNameTok.is(tok::code_completion)) { if (CodeComplete) CodeComplete->CodeCompleteMacroName(isDefineUndef == 1); setCodeCompletionReached(); LexUnexpandedToken(MacroNameTok); } if (!CheckMacroName(MacroNameTok, isDefineUndef)) 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(); } } /// \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 /// true, then we consider macros that expand to zero tokens as being ok. void Preprocessor::CheckEndOfDirective(const char *DirType, bool EnableMacros) { Token Tmp; // 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); // 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); if (Tmp.isNot(tok::eod)) { // Add a fixit in GNU/C99/C++ mode. Don't offer a fixit for strict-C89, // or if this is a macro-style preprocessing directive, because it is more // trouble than it is worth to insert /**/ and check that there is no /**/ // in the range also. FixItHint Hint; if ((LangOpts.GNUMode || LangOpts.C99 || LangOpts.CPlusPlus) && !CurTokenLexer) Hint = FixItHint::CreateInsertion(Tmp.getLocation(),"//"); Diag(Tmp, diag::ext_pp_extra_tokens_at_eol) << DirType << Hint; DiscardUntilEndOfDirective(); } } /// 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 /// FoundNonSkipPortion is true, then we have already emitted code for part of /// 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. void Preprocessor::SkipExcludedConditionalBlock(SourceLocation IfTokenLoc, bool FoundNonSkipPortion, bool FoundElse, SourceLocation ElseLoc) { ++NumSkipped; assert(!CurTokenLexer && CurPPLexer && "Lexing a macro, not a file?"); CurPPLexer->pushConditionalLevel(IfTokenLoc, /*isSkipping*/false, FoundNonSkipPortion, FoundElse); if (CurPTHLexer) { PTHSkipExcludedConditionalBlock(); return; } // Enter raw mode to disable identifier lookup (and thus macro expansion), // disabling warnings, etc. CurPPLexer->LexingRawMode = true; Token Tok; while (1) { CurLexer->Lex(Tok); if (Tok.is(tok::code_completion)) { if (CodeComplete) CodeComplete->CodeCompleteInConditionalExclusion(); setCodeCompletionReached(); continue; } // 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. while (!CurPPLexer->ConditionalStack.empty()) { if (CurLexer->getFileLoc() != CodeCompletionFileLoc) Diag(CurPPLexer->ConditionalStack.back().IfLoc, diag::err_pp_unterminated_conditional); CurPPLexer->ConditionalStack.pop_back(); } // Just return and let the caller lex after this #include. break; } // If this token is not a preprocessor directive, just skip it. if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine()) continue; // 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 EOD token (this terminates the macro). CurPPLexer->ParsingPreprocessorDirective = true; if (CurLexer) CurLexer->SetKeepWhitespaceMode(false); // Read the next token, the directive flavor. LexUnexpandedToken(Tok); // If this isn't an identifier directive (e.g. is "# 1\n" or "#\n", or // something bogus), skip it. if (Tok.isNot(tok::raw_identifier)) { CurPPLexer->ParsingPreprocessorDirective = false; // Restore comment saving mode. if (CurLexer) CurLexer->resetExtendedTokenMode(); 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. StringRef RI = Tok.getRawIdentifier(); char FirstChar = RI[0]; if (FirstChar >= 'a' && FirstChar <= 'z' && FirstChar != 'i' && FirstChar != 'e') { CurPPLexer->ParsingPreprocessorDirective = false; // Restore comment saving mode. if (CurLexer) CurLexer->resetExtendedTokenMode(); continue; } // Get the identifier name without trigraphs or embedded newlines. Note // that we can't use Tok.getIdentifierInfo() because its lookup is disabled // when skipping. char DirectiveBuf[20]; StringRef Directive; if (!Tok.needsCleaning() && RI.size() < 20) { Directive = RI; } else { std::string DirectiveStr = getSpelling(Tok); unsigned IdLen = DirectiveStr.size(); if (IdLen >= 20) { CurPPLexer->ParsingPreprocessorDirective = false; // Restore comment saving mode. if (CurLexer) CurLexer->resetExtendedTokenMode(); continue; } memcpy(DirectiveBuf, &DirectiveStr[0], IdLen); Directive = StringRef(DirectiveBuf, IdLen); } if (Directive.startswith("if")) { StringRef Sub = Directive.substr(2); if (Sub.empty() || // "if" Sub == "def" || // "ifdef" Sub == "ndef") { // "ifndef" // We know the entire #if/#ifdef/#ifndef block will be skipped, don't // bother parsing the condition. DiscardUntilEndOfDirective(); CurPPLexer->pushConditionalLevel(Tok.getLocation(), /*wasskipping*/true, /*foundnonskip*/false, /*foundelse*/false); } } else if (Directive[0] == 'e') { StringRef Sub = Directive.substr(1); if (Sub == "ndif") { // "endif" PPConditionalInfo CondInfo; CondInfo.WasSkipping = true; // Silence bogus warning. bool InCond = CurPPLexer->popConditionalLevel(CondInfo); (void)InCond; // Silence warning in no-asserts mode. assert(!InCond && "Can't be skipping if not in a conditional!"); // If we popped the outermost skipping block, we're done skipping! if (!CondInfo.WasSkipping) { // Restore the value of LexingRawMode so that trailing comments // are handled correctly, if we've reached the outermost block. CurPPLexer->LexingRawMode = false; CheckEndOfDirective("endif"); CurPPLexer->LexingRawMode = true; if (Callbacks) Callbacks->Endif(Tok.getLocation(), CondInfo.IfLoc); break; } else { DiscardUntilEndOfDirective(); } } else if (Sub == "lse") { // "else". // #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. PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel(); // If this is a #else with a #else before it, report the error. if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_else_after_else); // Note that we've seen a #else in this conditional. CondInfo.FoundElse = true; // 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; // Restore the value of LexingRawMode so that trailing comments // are handled correctly. CurPPLexer->LexingRawMode = false; CheckEndOfDirective("else"); CurPPLexer->LexingRawMode = true; if (Callbacks) Callbacks->Else(Tok.getLocation(), CondInfo.IfLoc); break; } else { DiscardUntilEndOfDirective(); // C99 6.10p4. } } else if (Sub == "lif") { // "elif". PPConditionalInfo &CondInfo = CurPPLexer->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); // 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 { const SourceLocation CondBegin = CurPPLexer->getSourceLocation(); // Restore the value of LexingRawMode so that identifiers are // looked up, etc, inside the #elif expression. assert(CurPPLexer->LexingRawMode && "We have to be skipping here!"); CurPPLexer->LexingRawMode = false; IdentifierInfo *IfNDefMacro = nullptr; const bool CondValue = EvaluateDirectiveExpression(IfNDefMacro); CurPPLexer->LexingRawMode = true; if (Callbacks) { const SourceLocation CondEnd = CurPPLexer->getSourceLocation(); Callbacks->Elif(Tok.getLocation(), SourceRange(CondBegin, CondEnd), (CondValue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False), CondInfo.IfLoc); } // If this condition is true, enter it! if (CondValue) { CondInfo.FoundNonSkip = true; break; } } } } CurPPLexer->ParsingPreprocessorDirective = false; // Restore comment saving mode. if (CurLexer) CurLexer->resetExtendedTokenMode(); } // 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. CurPPLexer->LexingRawMode = false; if (Callbacks) { SourceLocation BeginLoc = ElseLoc.isValid() ? ElseLoc : IfTokenLoc; Callbacks->SourceRangeSkipped(SourceRange(BeginLoc, Tok.getLocation())); } } void Preprocessor::PTHSkipExcludedConditionalBlock() { while (1) { assert(CurPTHLexer); assert(CurPTHLexer->LexingRawMode == false); // 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); (void)InCond; // Silence warning in no-asserts mode. assert(!InCond && "Can't be skipping if not in a conditional!"); break; } // We have reached a '#else' or '#elif'. Lex the next token to get // the directive flavor. Token Tok; LexUnexpandedToken(Tok); // 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; // If the #if block wasn't entered then enter the #else block now. if (!CondInfo.FoundNonSkip) { CondInfo.FoundNonSkip = true; // Scan until the eod token. CurPTHLexer->ParsingPreprocessorDirective = true; DiscardUntilEndOfDirective(); CurPTHLexer->ParsingPreprocessorDirective = false; break; } // Otherwise skip this block. continue; } 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); // If this is in a skipping block or if we're already handled this #if // block, don't bother parsing the condition. We just skip this block. if (CondInfo.FoundNonSkip) continue; // Evaluate the condition of the #elif. IdentifierInfo *IfNDefMacro = nullptr; 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. continue; } } Module *Preprocessor::getModuleForLocation(SourceLocation FilenameLoc) { ModuleMap &ModMap = HeaderInfo.getModuleMap(); if (SourceMgr.isInMainFile(FilenameLoc)) { if (Module *CurMod = getCurrentModule()) return CurMod; // Compiling a module. return HeaderInfo.getModuleMap().SourceModule; // Compiling a source. } // 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(FilenameLoc)); if (const FileEntry *EntryOfIncl = SourceMgr.getFileEntryForID(IDOfIncl)) { // The include comes from a file. return ModMap.findModuleForHeader(EntryOfIncl).getModule(); } else { // The include does not come from a file, // so it is probably a module compilation. return getCurrentModule(); } } const FileEntry *Preprocessor::LookupFile( SourceLocation FilenameLoc, StringRef Filename, bool isAngled, const DirectoryLookup *FromDir, const DirectoryLookup *&CurDir, SmallVectorImpl *SearchPath, SmallVectorImpl *RelativePath, ModuleMap::KnownHeader *SuggestedModule, bool SkipCache) { // If the header lookup mechanism may be relative to the current inclusion // stack, record the parent #includes. SmallVector Includers; if (!FromDir) { FileID FID = getCurrentFileLexer()->getFileID(); const FileEntry *FileEnt = SourceMgr.getFileEntryForID(FID); // If there is no file entry associated with this file, it must be the // predefines 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) as if they came from the main file, this // affects file lookup etc. if (!FileEnt) FileEnt = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID()); if (FileEnt) Includers.push_back(FileEnt); // 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 if (LangOpts.MSVCCompat && !isAngled) { for (unsigned i = 0, e = IncludeMacroStack.size(); i != e; ++i) { IncludeStackInfo &ISEntry = IncludeMacroStack[e - i - 1]; if (IsFileLexer(ISEntry)) if ((FileEnt = SourceMgr.getFileEntryForID( ISEntry.ThePPLexer->getFileID()))) Includers.push_back(FileEnt); } } } // Do a standard file entry lookup. CurDir = CurDirLookup; const FileEntry *FE = HeaderInfo.LookupFile( Filename, FilenameLoc, isAngled, FromDir, CurDir, Includers, SearchPath, RelativePath, SuggestedModule, SkipCache); if (FE) { if (SuggestedModule && !LangOpts.AsmPreprocessor) HeaderInfo.getModuleMap().diagnoseHeaderInclusion( getModuleForLocation(FilenameLoc), FilenameLoc, Filename, FE); return FE; } const FileEntry *CurFileEnt; // 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. if (IsFileLexer()) { if ((CurFileEnt = SourceMgr.getFileEntryForID(CurPPLexer->getFileID()))) { if ((FE = HeaderInfo.LookupSubframeworkHeader(Filename, CurFileEnt, SearchPath, RelativePath, SuggestedModule))) { if (SuggestedModule && !LangOpts.AsmPreprocessor) HeaderInfo.getModuleMap().diagnoseHeaderInclusion( getModuleForLocation(FilenameLoc), FilenameLoc, Filename, FE); return FE; } } } for (unsigned i = 0, e = IncludeMacroStack.size(); i != e; ++i) { IncludeStackInfo &ISEntry = IncludeMacroStack[e-i-1]; if (IsFileLexer(ISEntry)) { if ((CurFileEnt = SourceMgr.getFileEntryForID(ISEntry.ThePPLexer->getFileID()))) { if ((FE = HeaderInfo.LookupSubframeworkHeader( Filename, CurFileEnt, SearchPath, RelativePath, SuggestedModule))) { if (SuggestedModule && !LangOpts.AsmPreprocessor) HeaderInfo.getModuleMap().diagnoseHeaderInclusion( getModuleForLocation(FilenameLoc), FilenameLoc, Filename, FE); return FE; } } } } // Otherwise, we really couldn't find the file. return nullptr; } //===----------------------------------------------------------------------===// // Preprocessor Directive Handling. //===----------------------------------------------------------------------===// class Preprocessor::ResetMacroExpansionHelper { public: ResetMacroExpansionHelper(Preprocessor *pp) : PP(pp), save(pp->DisableMacroExpansion) { if (pp->MacroExpansionInDirectivesOverride) pp->DisableMacroExpansion = false; } ~ResetMacroExpansionHelper() { PP->DisableMacroExpansion = save; } private: Preprocessor *PP; bool save; }; /// HandleDirective - This callback is invoked when the lexer sees a # token /// at the start of a line. This consumes the directive, modifies the /// 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? // 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 // EOD token (which terminates the directive). CurPPLexer->ParsingPreprocessorDirective = true; if (CurLexer) CurLexer->SetKeepWhitespaceMode(false); bool ImmediatelyAfterTopLevelIfndef = CurPPLexer->MIOpt.getImmediatelyAfterTopLevelIfndef(); CurPPLexer->MIOpt.resetImmediatelyAfterTopLevelIfndef(); ++NumDirectives; // We are about to read a token. For the multiple-include optimization FA to // work, we have to remember if we had read any tokens *before* this // pp-directive. bool ReadAnyTokensBeforeDirective =CurPPLexer->MIOpt.getHasReadAnyTokensVal(); // Save the '#' token in case we need to return it later. Token SavedHash = Result; // Read the next token, the directive flavor. This isn't expanded due to // C99 6.10.3p8. LexUnexpandedToken(Result); // C99 6.10.3p11: Is this preprocessor directive in macro invocation? e.g.: // #define A(x) #x // A(abc // #warning blah // def) // 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: Diag(Result, diag::err_embedded_include) << II->getName(); DiscardUntilEndOfDirective(); return; default: break; } } Diag(Result, diag::ext_embedded_directive); } // Temporarily enable macro expansion if set so // and reset to previous state when returning from this function. ResetMacroExpansionHelper helper(this); switch (Result.getKind()) { case tok::eod: return; // null directive. case tok::code_completion: if (CodeComplete) CodeComplete->CodeCompleteDirective( CurPPLexer->getConditionalStackDepth() > 0); setCodeCompletionReached(); return; case tok::numeric_constant: // # 7 GNU line marker directive. if (getLangOpts().AsmPreprocessor) break; // # 4 is not a preprocessor directive in .S files. return HandleDigitDirective(Result); default: IdentifierInfo *II = Result.getIdentifierInfo(); if (!II) break; // Not an identifier. // 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); // C99 6.10.2 - Source File Inclusion. case tok::pp_include: // Handle #include. return HandleIncludeDirective(SavedHash.getLocation(), Result); case tok::pp___include_macros: // Handle -imacros. return HandleIncludeMacrosDirective(SavedHash.getLocation(), Result); // C99 6.10.3 - Macro Replacement. case tok::pp_define: return HandleDefineDirective(Result, ImmediatelyAfterTopLevelIfndef); case tok::pp_undef: return HandleUndefDirective(Result); // C99 6.10.4 - Line Control. case tok::pp_line: return HandleLineDirective(Result); // C99 6.10.5 - Error Directive. case tok::pp_error: return HandleUserDiagnosticDirective(Result, false); // C99 6.10.6 - Pragma Directive. case tok::pp_pragma: return HandlePragmaDirective(SavedHash.getLocation(), PIK_HashPragma); // GNU Extensions. case tok::pp_import: return HandleImportDirective(SavedHash.getLocation(), Result); case tok::pp_include_next: return HandleIncludeNextDirective(SavedHash.getLocation(), Result); 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; case tok::pp___public_macro: if (getLangOpts().Modules) return HandleMacroPublicDirective(Result); break; case tok::pp___private_macro: if (getLangOpts().Modules) return HandleMacroPrivateDirective(Result); break; } break; } // 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. if (getLangOpts().AsmPreprocessor) { Token *Toks = new Token[2]; // Return the # and the token after it. Toks[0] = SavedHash; Toks[1] = Result; // 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); // 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. EnterTokenStream(Toks, 2, false, true); return; } // If we reached here, the preprocessing token is not valid! Diag(Result, diag::err_pp_invalid_directive); // Read the rest of the PP line. DiscardUntilEndOfDirective(); // Okay, we're done parsing the directive. } /// 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, unsigned DiagID, Preprocessor &PP, bool IsGNULineDirective=false) { if (DigitTok.isNot(tok::numeric_constant)) { PP.Diag(DigitTok, DiagID); if (DigitTok.isNot(tok::eod)) PP.DiscardUntilEndOfDirective(); return true; } SmallString<64> IntegerBuffer; IntegerBuffer.resize(DigitTok.getLength()); const char *DigitTokBegin = &IntegerBuffer[0]; bool Invalid = false; unsigned ActualLength = PP.getSpelling(DigitTok, DigitTokBegin, &Invalid); if (Invalid) return true; // 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) { // C++1y [lex.fcon]p1: // Optional separating single quotes in a digit-sequence are ignored if (DigitTokBegin[i] == '\'') continue; if (!isDigit(DigitTokBegin[i])) { PP.Diag(PP.AdvanceToTokenCharacter(DigitTok.getLocation(), i), diag::err_pp_line_digit_sequence) << IsGNULineDirective; PP.DiscardUntilEndOfDirective(); return true; } unsigned NextVal = Val*10+(DigitTokBegin[i]-'0'); if (NextVal < Val) { // overflow. PP.Diag(DigitTok, DiagID); PP.DiscardUntilEndOfDirective(); return true; } Val = NextVal; } if (DigitTokBegin[0] == '0' && Val) PP.Diag(DigitTok.getLocation(), diag::warn_pp_line_decimal) << IsGNULineDirective; return false; } /// \brief Handle a \#line directive: C99 6.10.4. /// /// The two acceptable forms are: /// \verbatim /// # line digit-sequence /// # line digit-sequence "s-char-sequence" /// \endverbatim 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; if (GetLineValue(DigitTok, LineNo, diag::err_pp_line_requires_integer,*this)) return; if (LineNo == 0) Diag(DigitTok, diag::ext_pp_line_zero); // Enforce C99 6.10.4p3: "The digit sequence shall not specify ... a // number greater than 2147483647". C90 requires that the line # be <= 32767. unsigned LineLimit = 32768U; if (LangOpts.C99 || LangOpts.CPlusPlus11) LineLimit = 2147483648U; if (LineNo >= LineLimit) Diag(DigitTok, diag::ext_pp_line_too_big) << LineLimit; else if (LangOpts.CPlusPlus11 && LineNo >= 32768U) Diag(DigitTok, diag::warn_cxx98_compat_pp_line_too_big); int FilenameID = -1; Token StrTok; Lex(StrTok); // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a // string followed by eod. if (StrTok.is(tok::eod)) ; // ok else if (StrTok.isNot(tok::string_literal)) { Diag(StrTok, diag::err_pp_line_invalid_filename); return DiscardUntilEndOfDirective(); } else if (StrTok.hasUDSuffix()) { Diag(StrTok, diag::err_invalid_string_udl); return DiscardUntilEndOfDirective(); } else { // Parse and validate the string, converting it into a unique ID. StringLiteralParser Literal(StrTok, *this); assert(Literal.isAscii() && "Didn't allow wide strings in"); if (Literal.hadError) return DiscardUntilEndOfDirective(); if (Literal.Pascal) { Diag(StrTok, diag::err_pp_linemarker_invalid_filename); return DiscardUntilEndOfDirective(); } FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString()); // Verify that there is nothing after the string, other than EOD. Because // of C99 6.10.4p5, macros that expand to empty tokens are ok. CheckEndOfDirective("line", true); } SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID); if (Callbacks) Callbacks->FileChanged(CurPPLexer->getSourceLocation(), PPCallbacks::RenameFile, SrcMgr::C_User); } /// 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); if (FlagTok.is(tok::eod)) return false; if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP)) return true; if (FlagVal == 1) { IsFileEntry = true; PP.Lex(FlagTok); if (FlagTok.is(tok::eod)) return false; if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP)) return true; } else if (FlagVal == 2) { IsFileExit = true; 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 = SM.getDecomposedExpansionLoc(FlagTok.getLocation()).first; PresumedLoc PLoc = SM.getPresumedLoc(FlagTok.getLocation()); if (PLoc.isInvalid()) return true; // 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() || SM.getDecomposedExpansionLoc(IncLoc).first != CurFileID) { PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_pop); PP.DiscardUntilEndOfDirective(); return true; } PP.Lex(FlagTok); if (FlagTok.is(tok::eod)) return false; 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); PP.DiscardUntilEndOfDirective(); return true; } IsSystemHeader = true; PP.Lex(FlagTok); if (FlagTok.is(tok::eod)) return false; if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP)) return true; // We must have 4 if there is yet another flag. if (FlagVal != 4) { PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag); PP.DiscardUntilEndOfDirective(); return true; } IsExternCHeader = true; PP.Lex(FlagTok); if (FlagTok.is(tok::eod)) return false; // There are no more valid flags here. PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag); PP.DiscardUntilEndOfDirective(); return true; } /// HandleDigitDirective - Handle a GNU line marker directive, whose syntax is /// one of the following forms: /// /// # 42 /// # 42 "file" ('1' | '2')? /// # 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, *this, true)) return; Token StrTok; Lex(StrTok); bool IsFileEntry = false, IsFileExit = false; bool IsSystemHeader = false, IsExternCHeader = false; int FilenameID = -1; // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a // string followed by eod. if (StrTok.is(tok::eod)) ; // ok else if (StrTok.isNot(tok::string_literal)) { Diag(StrTok, diag::err_pp_linemarker_invalid_filename); return DiscardUntilEndOfDirective(); } else if (StrTok.hasUDSuffix()) { Diag(StrTok, diag::err_invalid_string_udl); return DiscardUntilEndOfDirective(); } else { // Parse and validate the string, converting it into a unique ID. StringLiteralParser Literal(StrTok, *this); assert(Literal.isAscii() && "Didn't allow wide strings in"); if (Literal.hadError) return DiscardUntilEndOfDirective(); if (Literal.Pascal) { Diag(StrTok, diag::err_pp_linemarker_invalid_filename); return DiscardUntilEndOfDirective(); } FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString()); // If a filename was present, read any flags that are present. if (ReadLineMarkerFlags(IsFileEntry, IsFileExit, IsSystemHeader, IsExternCHeader, *this)) return; } // Create a line note with this information. SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, IsFileEntry, IsFileExit, IsSystemHeader, IsExternCHeader); // 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; Callbacks->FileChanged(CurPPLexer->getSourceLocation(), Reason, FileKind); } } /// HandleUserDiagnosticDirective - Handle a #warning or #error directive. /// void Preprocessor::HandleUserDiagnosticDirective(Token &Tok, bool isWarning) { // PTH doesn't emit #warning or #error directives. if (CurPTHLexer) return CurPTHLexer->DiscardToEndOfLine(); // 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. SmallString<128> Message; CurLexer->ReadToEndOfLine(&Message); // Find the first non-whitespace character, so that we can make the // diagnostic more succinct. StringRef Msg = Message.str().ltrim(" "); if (isWarning) Diag(Tok, diag::pp_hash_warning) << Msg; else Diag(Tok, diag::err_pp_hash_error) << Msg; } /// HandleIdentSCCSDirective - Handle a #ident/#sccs directive. /// void Preprocessor::HandleIdentSCCSDirective(Token &Tok) { // Yes, this directive is an extension. Diag(Tok, diag::ext_pp_ident_directive); // Read the string argument. Token StrTok; Lex(StrTok); // If the token kind isn't a string, it's a malformed directive. if (StrTok.isNot(tok::string_literal) && StrTok.isNot(tok::wide_string_literal)) { Diag(StrTok, diag::err_pp_malformed_ident); if (StrTok.isNot(tok::eod)) DiscardUntilEndOfDirective(); return; } if (StrTok.hasUDSuffix()) { Diag(StrTok, diag::err_invalid_string_udl); return DiscardUntilEndOfDirective(); } // Verify that there is nothing after the string, other than EOD. CheckEndOfDirective("ident"); if (Callbacks) { bool Invalid = false; std::string Str = getSpelling(StrTok, &Invalid); if (!Invalid) Callbacks->Ident(Tok.getLocation(), Str); } } /// \brief Handle a #public directive. void Preprocessor::HandleMacroPublicDirective(Token &Tok) { Token MacroNameTok; ReadMacroName(MacroNameTok, 2); // Error reading macro name? If so, diagnostic already issued. if (MacroNameTok.is(tok::eod)) return; // Check to see if this is the last token on the #__public_macro line. CheckEndOfDirective("__public_macro"); IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); // Okay, we finally have a valid identifier to undef. MacroDirective *MD = getMacroDirective(II); // If the macro is not defined, this is an error. if (!MD) { Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II; return; } // Note that this macro has now been exported. appendMacroDirective(II, AllocateVisibilityMacroDirective( MacroNameTok.getLocation(), /*IsPublic=*/true)); } /// \brief Handle a #private directive. void Preprocessor::HandleMacroPrivateDirective(Token &Tok) { Token MacroNameTok; ReadMacroName(MacroNameTok, 2); // Error reading macro name? If so, diagnostic already issued. if (MacroNameTok.is(tok::eod)) return; // Check to see if this is the last token on the #__private_macro line. CheckEndOfDirective("__private_macro"); IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); // Okay, we finally have a valid identifier to undef. MacroDirective *MD = getMacroDirective(II); // If the macro is not defined, this is an error. if (!MD) { Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II; return; } // Note that this macro has now been marked private. appendMacroDirective(II, AllocateVisibilityMacroDirective( MacroNameTok.getLocation(), /*IsPublic=*/false)); } //===----------------------------------------------------------------------===// // Preprocessor Include Directive Handling. //===----------------------------------------------------------------------===// /// GetIncludeFilenameSpelling - Turn the specified lexer token into a fully /// checked and spelled filename, e.g. as an operand of \#include. This returns /// 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, StringRef &Buffer) { // Get the text form of the filename. assert(!Buffer.empty() && "Can't have tokens with empty spellings!"); // Make sure the filename is or "x". bool isAngled; if (Buffer[0] == '<') { if (Buffer.back() != '>') { Diag(Loc, diag::err_pp_expects_filename); Buffer = StringRef(); return true; } isAngled = true; } else if (Buffer[0] == '"') { if (Buffer.back() != '"') { Diag(Loc, diag::err_pp_expects_filename); Buffer = StringRef(); return true; } isAngled = false; } else { Diag(Loc, diag::err_pp_expects_filename); Buffer = StringRef(); return true; } // Diagnose #include "" as invalid. if (Buffer.size() <= 2) { Diag(Loc, diag::err_pp_empty_filename); Buffer = StringRef(); return true; } // Skip the brackets. Buffer = Buffer.substr(1, Buffer.size()-2); return isAngled; } // \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 // \#include FOO // \endcode // because in this case, "" 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, SourceLocation &End) { Token CurTok; Lex(CurTok); while (CurTok.isNot(tok::eod)) { End = CurTok.getLocation(); // FIXME: Provide code completion for #includes. if (CurTok.is(tok::code_completion)) { setCodeCompletionReached(); Lex(CurTok); continue; } // 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(' '); // Get the spelling of the token, directly into FilenameBuffer if possible. unsigned PreAppendSize = FilenameBuffer.size(); FilenameBuffer.resize(PreAppendSize+CurTok.getLength()); const char *BufPtr = &FilenameBuffer[PreAppendSize]; unsigned ActualLen = getSpelling(CurTok, BufPtr); // If the token was spelled somewhere else, copy it into FilenameBuffer. if (BufPtr != &FilenameBuffer[PreAppendSize]) memcpy(&FilenameBuffer[PreAppendSize], BufPtr, ActualLen); // Resize FilenameBuffer to the correct size. if (CurTok.getLength() != ActualLen) FilenameBuffer.resize(PreAppendSize+ActualLen); // If we found the '>' marker, return success. if (CurTok.is(tok::greater)) return false; Lex(CurTok); } // If we hit the eod marker, emit an error and return true so that the caller // knows the EOD has been read. Diag(CurTok.getLocation(), diag::err_pp_expects_filename); return true; } /// \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) { Token *Tok = new Token[1]; Tok[0].startToken(); Tok[0].setKind(Kind); Tok[0].setLocation(Begin); Tok[0].setAnnotationEndLoc(End); Tok[0].setAnnotationValue(AnnotationVal); PP.EnterTokenStream(Tok, 1, true, true); } /// 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 /// specifies the file to start searching from. void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc, Token &IncludeTok, const DirectoryLookup *LookupFrom, bool isImport) { Token FilenameTok; CurPPLexer->LexIncludeFilename(FilenameTok); // Reserve a buffer to get the spelling. SmallString<128> FilenameBuffer; StringRef Filename; SourceLocation End; SourceLocation CharEnd; // the end of this directive, in characters switch (FilenameTok.getKind()) { case tok::eod: // If the token kind is EOD, the error has already been diagnosed. return; case tok::angle_string_literal: case tok::string_literal: Filename = getSpelling(FilenameTok, FilenameBuffer); End = FilenameTok.getLocation(); CharEnd = End.getLocWithOffset(FilenameTok.getLength()); break; case tok::less: // This could be a file coming from a macro expansion. In this // case, glue the tokens together into FilenameBuffer and interpret those. FilenameBuffer.push_back('<'); if (ConcatenateIncludeName(FilenameBuffer, End)) return; // Found but no ">"? Diagnostic already emitted. Filename = FilenameBuffer.str(); CharEnd = End.getLocWithOffset(1); break; default: Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename); DiscardUntilEndOfDirective(); return; } CharSourceRange FilenameRange = CharSourceRange::getCharRange(FilenameTok.getLocation(), CharEnd); StringRef OriginalFilename = Filename; bool isAngled = GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename); // If GetIncludeFilenameSpelling set the start ptr to null, there was an // error. if (Filename.empty()) { DiscardUntilEndOfDirective(); return; } // Verify that there is nothing after the filename, other than EOD. Note that // we allow macros that expand to nothing after the filename, because this // falls into the category of "#include pp-tokens new-line" specified in // C99 6.10.2p4. CheckEndOfDirective(IncludeTok.getIdentifierInfo()->getNameStart(), true); // Check that we don't have infinite #include recursion. if (IncludeMacroStack.size() == MaxAllowedIncludeStackDepth-1) { Diag(FilenameTok, diag::err_pp_include_too_deep); return; } // 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(); } if (HeaderInfo.HasIncludeAliasMap()) { // 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 // spelling for. StringRef NewName = HeaderInfo.MapHeaderToIncludeAlias(OriginalFilename); if (!NewName.empty()) Filename = NewName; } // Search include directories. const DirectoryLookup *CurDir; SmallString<1024> SearchPath; SmallString<1024> RelativePath; // We get the raw path only if we have 'Callbacks' to which we later pass // the path. ModuleMap::KnownHeader SuggestedModule; SourceLocation FilenameLoc = FilenameTok.getLocation(); SmallString<128> NormalizedPath; if (LangOpts.MSVCCompat) { NormalizedPath = Filename.str(); #ifndef LLVM_ON_WIN32 llvm::sys::path::native(NormalizedPath); #endif } const FileEntry *File = LookupFile( FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled, LookupFrom, CurDir, Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr, HeaderInfo.getHeaderSearchOpts().ModuleMaps ? &SuggestedModule : nullptr); if (Callbacks) { if (!File) { // Give the clients a chance to recover. SmallString<128> RecoveryPath; if (Callbacks->FileNotFound(Filename, RecoveryPath)) { if (const DirectoryEntry *DE = FileMgr.getDirectory(RecoveryPath)) { // Add the recovery path to the list of search paths. DirectoryLookup DL(DE, SrcMgr::C_User, false); HeaderInfo.AddSearchPath(DL, isAngled); // Try the lookup again, skipping the cache. File = LookupFile(FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled, LookupFrom, CurDir, nullptr, nullptr, HeaderInfo.getHeaderSearchOpts().ModuleMaps ? &SuggestedModule : nullptr, /*SkipCache*/ true); } } } if (!SuggestedModule || !getLangOpts().Modules) { // 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, /*ImportedModule=*/nullptr); } } if (!File) { if (!SuppressIncludeNotFoundError) { // If the file could not be located and it was included via angle // brackets, we can attempt a lookup as though it were a quoted path to // provide the user with a possible fixit. if (isAngled) { File = LookupFile( FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, false, LookupFrom, CurDir, Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr, HeaderInfo.getHeaderSearchOpts().ModuleMaps ? &SuggestedModule : nullptr); if (File) { SourceRange Range(FilenameTok.getLocation(), CharEnd); Diag(FilenameTok, diag::err_pp_file_not_found_not_fatal) << Filename << FixItHint::CreateReplacement(Range, "\"" + Filename.str() + "\""); } } // If the file is still not found, just go with the vanilla diagnostic if (!File) Diag(FilenameTok, diag::err_pp_file_not_found) << Filename; } if (!File) return; } // If we are supposed to import a module rather than including the header, // do so now. if (SuggestedModule && getLangOpts().Modules && SuggestedModule.getModule()->getTopLevelModuleName() != getLangOpts().ImplementationOfModule) { // Compute the module access path corresponding to this module. // FIXME: Should we have a second loadModule() overload to avoid this // extra lookup step? SmallVector, 2> Path; for (Module *Mod = SuggestedModule.getModule(); Mod; Mod = Mod->Parent) Path.push_back(std::make_pair(getIdentifierInfo(Mod->Name), FilenameTok.getLocation())); std::reverse(Path.begin(), Path.end()); // Warn that we're replacing the include/import with a module import. SmallString<128> PathString; for (unsigned I = 0, N = Path.size(); I != N; ++I) { if (I) PathString += '.'; PathString += Path[I].first->getName(); } int IncludeKind = 0; switch (IncludeTok.getIdentifierInfo()->getPPKeywordID()) { case tok::pp_include: IncludeKind = 0; break; case tok::pp_import: IncludeKind = 1; break; case tok::pp_include_next: IncludeKind = 2; break; case tok::pp___include_macros: IncludeKind = 3; break; default: llvm_unreachable("unknown include directive kind"); } // Determine whether we are actually building the module that this // include directive maps to. bool BuildingImportedModule = Path[0].first->getName() == getLangOpts().CurrentModule; if (!BuildingImportedModule && getLangOpts().ObjC2) { // If we're not building the imported module, warn that we're going // to automatically turn this inclusion directive into a module import. // We only do this in Objective-C, where we have a module-import syntax. CharSourceRange ReplaceRange(SourceRange(HashLoc, CharEnd), /*IsTokenRange=*/false); Diag(HashLoc, diag::warn_auto_module_import) << IncludeKind << PathString << FixItHint::CreateReplacement(ReplaceRange, "@@import " + PathString.str().str() + ";"); } // Load the module. Only make macros visible. We'll make the declarations // visible when the parser gets here. Module::NameVisibilityKind Visibility = Module::MacrosVisible; ModuleLoadResult Imported = TheModuleLoader.loadModule(IncludeTok.getLocation(), Path, Visibility, /*IsIncludeDirective=*/true); assert((Imported == nullptr || Imported == SuggestedModule.getModule()) && "the imported module is different than the suggested one"); if (!Imported && 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); } return; } // If this header isn't part of the module we're building, we're done. if (!BuildingImportedModule && Imported) { if (Callbacks) { Callbacks->InclusionDirective(HashLoc, IncludeTok, Filename, isAngled, FilenameRange, File, SearchPath, RelativePath, Imported); } if (IncludeKind != 3) { // Let the parser know that we hit a module import, and it should // make the module visible. // FIXME: Produce this as the current token directly, rather than // allocating a new token for it. EnterAnnotationToken(*this, HashLoc, End, tok::annot_module_include, Imported); } return; } // If we failed to find a submodule that we expected to find, we can // continue. Otherwise, there's an error in the included file, so we // don't want to include it. if (!BuildingImportedModule && !Imported.isMissingExpected()) { return; } } if (Callbacks && SuggestedModule) { // We didn't notify the callback object that we've seen an inclusion // directive before. Now that we are parsing the include normally and not // turning it to a module import, notify the callback object. Callbacks->InclusionDirective(HashLoc, IncludeTok, Filename, isAngled, FilenameRange, File, SearchPath, RelativePath, /*ImportedModule=*/nullptr); } // The #included file will be considered to be a system header if either it is // in a system include directory, or if the #includer is a system include // header. SrcMgr::CharacteristicKind FileCharacter = std::max(HeaderInfo.getFileDirFlavor(File), SourceMgr.getFileCharacteristic(FilenameTok.getLocation())); // Ask HeaderInfo if we should enter this #include file. If not, #including // this file will have no effect. if (!HeaderInfo.ShouldEnterIncludeFile(File, isImport)) { if (Callbacks) Callbacks->FileSkipped(*File, FilenameTok, FileCharacter); return; } // Look up the file, create a File ID for it. 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); assert(!FID.isInvalid() && "Expected valid file ID"); // Determine if we're switching to building a new submodule, and which one. ModuleMap::KnownHeader BuildingModule; if (getLangOpts().Modules && !getLangOpts().CurrentModule.empty()) { Module *RequestingModule = getModuleForLocation(FilenameLoc); BuildingModule = HeaderInfo.getModuleMap().findModuleForHeader(File, RequestingModule); } // If all is good, enter the new file! if (EnterSourceFile(FID, CurDir, FilenameTok.getLocation())) return; // If we're walking into another part of the same module, let the parser // know that any future declarations are within that other submodule. if (BuildingModule) { assert(!CurSubmodule && "should not have marked this as a module yet"); CurSubmodule = BuildingModule.getModule(); EnterAnnotationToken(*this, HashLoc, End, tok::annot_module_begin, CurSubmodule); } } /// HandleIncludeNextDirective - Implements \#include_next. /// void Preprocessor::HandleIncludeNextDirective(SourceLocation HashLoc, Token &IncludeNextTok) { Diag(IncludeNextTok, diag::ext_pp_include_next_directive); // #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; if (isInPrimaryFile()) { Lookup = nullptr; Diag(IncludeNextTok, diag::pp_include_next_in_primary); } else if (!Lookup) { Diag(IncludeNextTok, diag::pp_include_next_absolute_path); } else { // Start looking up in the next directory. ++Lookup; } return HandleIncludeDirective(HashLoc, IncludeNextTok, Lookup); } /// HandleMicrosoftImportDirective - Implements \#import for Microsoft Mode 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 ); // Read tokens until we get to the end of the directive. Note that the // directive can be split over multiple lines using the backslash character. DiscardUntilEndOfDirective(); } /// HandleImportDirective - Implements \#import. /// void Preprocessor::HandleImportDirective(SourceLocation HashLoc, Token &ImportTok) { if (!LangOpts.ObjC1) { // #import is standard for ObjC. if (LangOpts.MSVCCompat) return HandleMicrosoftImportDirective(ImportTok); Diag(ImportTok, diag::ext_pp_import_directive); } return HandleIncludeDirective(HashLoc, ImportTok, nullptr, true); } /// 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). void Preprocessor::HandleIncludeMacrosDirective(SourceLocation HashLoc, Token &IncludeMacrosTok) { // 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), "") != 0) { Diag(IncludeMacrosTok.getLocation(), diag::pp_include_macros_out_of_predefines); DiscardUntilEndOfDirective(); return; } // Treat this as a normal #include for checking purposes. If this is // successful, it will push a new lexer onto the include stack. HandleIncludeDirective(HashLoc, IncludeMacrosTok, nullptr, false); Token TmpTok; do { Lex(TmpTok); assert(TmpTok.isNot(tok::eof) && "Didn't find end of -imacros!"); } while (TmpTok.isNot(tok::hashhash)); } //===----------------------------------------------------------------------===// // 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. bool Preprocessor::ReadMacroDefinitionArgList(MacroInfo *MI, Token &Tok) { SmallVector Arguments; while (1) { LexUnexpandedToken(Tok); switch (Tok.getKind()) { case tok::r_paren: // Found the end of the argument list. if (Arguments.empty()) // #define FOO() 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 if (!LangOpts.C99) Diag(Tok, LangOpts.CPlusPlus11 ? diag::warn_cxx98_compat_variadic_macro : diag::ext_variadic_macro); // OpenCL v1.2 s6.9.e: variadic macros are not supported. if (LangOpts.OpenCL) { Diag(Tok, diag::err_pp_opencl_variadic_macros); return true; } // 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(); MI->setArgumentList(&Arguments[0], Arguments.size(), BP); return false; case tok::eod: // #define X( 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(); if (!II) { // #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. if (std::find(Arguments.begin(), Arguments.end(), II) != Arguments.end()) { // C99 6.10.3p6 Diag(Tok, diag::err_pp_duplicate_name_in_arg_list) << II; return true; } // Add the argument to the macro info. Arguments.push_back(II); // Lex the token after the identifier. LexUnexpandedToken(Tok); 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) MI->setArgumentList(&Arguments[0], Arguments.size(), BP); 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); // 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; } MI->setIsGNUVarargs(); MI->setArgumentList(&Arguments[0], Arguments.size(), BP); return false; } } } } /// HandleDefineDirective - Implements \#define. This consumes the entire macro /// line then lets the caller lex the next real token. void Preprocessor::HandleDefineDirective(Token &DefineTok, bool ImmediatelyAfterHeaderGuard) { ++NumDefined; Token MacroNameTok; ReadMacroName(MacroNameTok, 1); // Error reading macro name? If so, diagnostic already issued. if (MacroNameTok.is(tok::eod)) return; Token LastTok = MacroNameTok; // If we are supposed to keep comments in #defines, reenable comment saving // mode. if (CurLexer) CurLexer->SetCommentRetentionState(KeepMacroComments); // Create the new macro. MacroInfo *MI = AllocateMacroInfo(MacroNameTok.getLocation()); Token Tok; LexUnexpandedToken(Tok); // 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. if (Tok.is(tok::eod)) { if (ImmediatelyAfterHeaderGuard) { // Save this macro information since it may part of a header guard. CurPPLexer->MIOpt.SetDefinedMacro(MacroNameTok.getIdentifierInfo(), MacroNameTok.getLocation()); } // If there is no body to this macro, we have no special handling here. } 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)) { // This is a function-like macro definition. Read the argument list. MI->setIsFunctionLike(); if (ReadMacroDefinitionArgList(MI, LastTok)) { // Throw away the rest of the line. if (CurPPLexer->ParsingPreprocessorDirective) DiscardUntilEndOfDirective(); return; } // If this is a definition of a variadic C99 function-like macro, not using // the GNU named varargs extension, enabled __VA_ARGS__. // "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); // Read the first token after the arg list for down below. LexUnexpandedToken(Tok); } else if (LangOpts.C99 || LangOpts.CPlusPlus11) { // C99 requires whitespace between the macro definition and the body. Emit // a diagnostic for something like "#define X+". Diag(Tok, diag::ext_c99_whitespace_required_after_macro_name); } else { // 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); } if (!Tok.is(tok::eod)) LastTok = Tok; // Read the rest of the macro body. if (MI->isObjectLike()) { // Object-like macros are very simple, just read their body. while (Tok.isNot(tok::eod)) { LastTok = Tok; MI->AddTokenToBody(Tok); // Get the next token of the macro. LexUnexpandedToken(Tok); } } else { // 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. while (Tok.isNot(tok::eod)) { LastTok = Tok; if (Tok.isNot(tok::hash) && Tok.isNot(tok::hashhash)) { MI->AddTokenToBody(Tok); // Get the next token of the macro. LexUnexpandedToken(Tok); continue; } // 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; } 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. // 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(); // Things look ok, add the '##' token to the macro. MI->AddTokenToBody(LastTok); continue; } // Get the next token of the macro. LexUnexpandedToken(Tok); // Check for a valid macro arg identifier. if (Tok.getIdentifierInfo() == nullptr || 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. if (getLangOpts().AsmPreprocessor && Tok.isNot(tok::eod)) { LastTok.setKind(tok::unknown); MI->AddTokenToBody(LastTok); continue; } else { Diag(Tok, diag::err_pp_stringize_not_parameter); // Disable __VA_ARGS__ again. Ident__VA_ARGS__->setIsPoisoned(true); return; } } // Things look ok, add the '#' and param name tokens to the macro. MI->AddTokenToBody(LastTok); MI->AddTokenToBody(Tok); LastTok = Tok; // Get the next token of the macro. LexUnexpandedToken(Tok); } } // Disable __VA_ARGS__ again. Ident__VA_ARGS__->setIsPoisoned(true); // Check that there is no paste (##) operator at the beginning or end of the // 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; } } MI->setDefinitionEndLoc(LastTok.getLocation()); // Finally, if this identifier already had a macro defined for it, verify that // the macro bodies are identical, and issue diagnostics if they are not. if (const MacroInfo *OtherMI=getMacroInfo(MacroNameTok.getIdentifierInfo())) { // 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. if (!getDiagnostics().getSuppressSystemWarnings() || !SourceMgr.isInSystemHeader(DefineTok.getLocation())) { if (!OtherMI->isUsed() && OtherMI->isWarnIfUnused()) Diag(OtherMI->getDefinitionLoc(), diag::pp_macro_not_used); // Warn if defining "__LINE__" and other builtins, per C99 6.10.8/4 and // C++ [cpp.predefined]p4, but allow it as an extension. if (OtherMI->isBuiltinMacro()) Diag(MacroNameTok, diag::ext_pp_redef_builtin_macro); // Macros must be identical. This means all tokens and whitespace // separation must be the same. C99 6.10.3p2. else if (!OtherMI->isAllowRedefinitionsWithoutWarning() && !MI->isIdenticalTo(*OtherMI, *this, /*Syntactic=*/LangOpts.MicrosoftExt)) { Diag(MI->getDefinitionLoc(), diag::ext_pp_macro_redef) << MacroNameTok.getIdentifierInfo(); Diag(OtherMI->getDefinitionLoc(), diag::note_previous_definition); } } if (OtherMI->isWarnIfUnused()) WarnUnusedMacroLocs.erase(OtherMI->getDefinitionLoc()); } DefMacroDirective *MD = appendDefMacroDirective(MacroNameTok.getIdentifierInfo(), MI); 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. if (getSourceManager().isInMainFile(MI->getDefinitionLoc()) && !Diags->isIgnored(diag::pp_macro_not_used, MI->getDefinitionLoc())) { MI->setIsWarnIfUnused(true); WarnUnusedMacroLocs.insert(MI->getDefinitionLoc()); } // If the callbacks want to know, tell them about the macro definition. if (Callbacks) Callbacks->MacroDefined(MacroNameTok, MD); } /// HandleUndefDirective - Implements \#undef. /// void Preprocessor::HandleUndefDirective(Token &UndefTok) { ++NumUndefined; Token MacroNameTok; ReadMacroName(MacroNameTok, 2); // Error reading macro name? If so, diagnostic already issued. if (MacroNameTok.is(tok::eod)) return; // Check to see if this is the last token on the #undef line. CheckEndOfDirective("undef"); // Okay, we finally have a valid identifier to undef. MacroDirective *MD = getMacroDirective(MacroNameTok.getIdentifierInfo()); const MacroInfo *MI = MD ? MD->getMacroInfo() : nullptr; // If the callbacks want to know, tell them about the macro #undef. // Note: no matter if the macro was defined or not. if (Callbacks) Callbacks->MacroUndefined(MacroNameTok, MD); // If the macro is not defined, this is a noop undef, just return. if (!MI) return; if (!MI->isUsed() && MI->isWarnIfUnused()) Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used); if (MI->isWarnIfUnused()) WarnUnusedMacroLocs.erase(MI->getDefinitionLoc()); appendMacroDirective(MacroNameTok.getIdentifierInfo(), AllocateUndefMacroDirective(MacroNameTok.getLocation())); } //===----------------------------------------------------------------------===// // Preprocessor Conditional Directive Handling. //===----------------------------------------------------------------------===// /// 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. /// void Preprocessor::HandleIfdefDirective(Token &Result, bool isIfndef, bool ReadAnyTokensBeforeDirective) { ++NumIf; Token DirectiveTok = Result; Token MacroNameTok; ReadMacroName(MacroNameTok); // Error reading macro name? If so, diagnostic already issued. if (MacroNameTok.is(tok::eod)) { // 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; } // Check to see if this is the last token on the #if[n]def line. CheckEndOfDirective(isIfndef ? "ifndef" : "ifdef"); IdentifierInfo *MII = MacroNameTok.getIdentifierInfo(); MacroDirective *MD = getMacroDirective(MII); MacroInfo *MI = MD ? MD->getMacroInfo() : nullptr; if (CurPPLexer->getConditionalStackDepth() == 0) { // 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. if (!ReadAnyTokensBeforeDirective && !MI) { assert(isIfndef && "#ifdef shouldn't reach here"); CurPPLexer->MIOpt.EnterTopLevelIfndef(MII, MacroNameTok.getLocation()); } else CurPPLexer->MIOpt.EnterTopLevelConditional(); } // If there is a macro, process it. if (MI) // Mark it used. markMacroAsUsed(MI); if (Callbacks) { if (isIfndef) Callbacks->Ifndef(DirectiveTok.getLocation(), MacroNameTok, MD); else Callbacks->Ifdef(DirectiveTok.getLocation(), MacroNameTok, MD); } // 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. CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(), /*wasskip*/false, /*foundnonskip*/true, /*foundelse*/false); } else { // No, skip the contents of this block. SkipExcludedConditionalBlock(DirectiveTok.getLocation(), /*Foundnonskip*/false, /*FoundElse*/false); } } /// HandleIfDirective - Implements the \#if directive. /// void Preprocessor::HandleIfDirective(Token &IfToken, bool ReadAnyTokensBeforeDirective) { ++NumIf; // Parse and evaluate the conditional expression. IdentifierInfo *IfNDefMacro = nullptr; const SourceLocation ConditionalBegin = CurPPLexer->getSourceLocation(); const bool ConditionalTrue = EvaluateDirectiveExpression(IfNDefMacro); const SourceLocation ConditionalEnd = CurPPLexer->getSourceLocation(); // If this condition is equivalent to #ifndef X, and if this is the first // directive seen, handle it for the multiple-include optimization. if (CurPPLexer->getConditionalStackDepth() == 0) { if (!ReadAnyTokensBeforeDirective && IfNDefMacro && ConditionalTrue) // FIXME: Pass in the location of the macro name, not the 'if' token. CurPPLexer->MIOpt.EnterTopLevelIfndef(IfNDefMacro, IfToken.getLocation()); else CurPPLexer->MIOpt.EnterTopLevelConditional(); } if (Callbacks) Callbacks->If(IfToken.getLocation(), SourceRange(ConditionalBegin, ConditionalEnd), (ConditionalTrue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False)); // Should we include the stuff contained by this directive? if (ConditionalTrue) { // Yes, remember that we are inside a conditional, then lex the next token. CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false, /*foundnonskip*/true, /*foundelse*/false); } else { // No, skip the contents of this block. SkipExcludedConditionalBlock(IfToken.getLocation(), /*Foundnonskip*/false, /*FoundElse*/false); } } /// HandleEndifDirective - Implements the \#endif directive. /// void Preprocessor::HandleEndifDirective(Token &EndifToken) { ++NumEndif; // Check that this is the whole directive. CheckEndOfDirective("endif"); PPConditionalInfo CondInfo; if (CurPPLexer->popConditionalLevel(CondInfo)) { // No conditionals on the stack: this is an #endif without an #if. Diag(EndifToken, diag::err_pp_endif_without_if); return; } // If this the end of a top-level #endif, inform MIOpt. if (CurPPLexer->getConditionalStackDepth() == 0) CurPPLexer->MIOpt.ExitTopLevelConditional(); assert(!CondInfo.WasSkipping && !CurPPLexer->LexingRawMode && "This code should only be reachable in the non-skipping case!"); if (Callbacks) Callbacks->Endif(EndifToken.getLocation(), CondInfo.IfLoc); } /// HandleElseDirective - Implements the \#else directive. /// void Preprocessor::HandleElseDirective(Token &Result) { ++NumElse; // #else directive in a non-skipping conditional... start skipping. CheckEndOfDirective("else"); PPConditionalInfo CI; if (CurPPLexer->popConditionalLevel(CI)) { Diag(Result, diag::pp_err_else_without_if); return; } // If this is a top-level #else, inform the MIOpt. if (CurPPLexer->getConditionalStackDepth() == 0) CurPPLexer->MIOpt.EnterTopLevelConditional(); // If this is a #else with a #else before it, report the error. if (CI.FoundElse) Diag(Result, diag::pp_err_else_after_else); if (Callbacks) Callbacks->Else(Result.getLocation(), CI.IfLoc); // Finally, skip the rest of the contents of this block. SkipExcludedConditionalBlock(CI.IfLoc, /*Foundnonskip*/true, /*FoundElse*/true, Result.getLocation()); } /// HandleElifDirective - Implements the \#elif directive. /// void Preprocessor::HandleElifDirective(Token &ElifToken) { ++NumElse; // #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). const SourceLocation ConditionalBegin = CurPPLexer->getSourceLocation(); DiscardUntilEndOfDirective(); const SourceLocation ConditionalEnd = CurPPLexer->getSourceLocation(); PPConditionalInfo CI; if (CurPPLexer->popConditionalLevel(CI)) { Diag(ElifToken, diag::pp_err_elif_without_if); return; } // If this is a top-level #elif, inform the MIOpt. if (CurPPLexer->getConditionalStackDepth() == 0) CurPPLexer->MIOpt.EnterTopLevelConditional(); // If this is a #elif with a #else before it, report the error. if (CI.FoundElse) Diag(ElifToken, diag::pp_err_elif_after_else); if (Callbacks) Callbacks->Elif(ElifToken.getLocation(), SourceRange(ConditionalBegin, ConditionalEnd), PPCallbacks::CVK_NotEvaluated, CI.IfLoc); // Finally, skip the rest of the contents of this block. SkipExcludedConditionalBlock(CI.IfLoc, /*Foundnonskip*/true, /*FoundElse*/CI.FoundElse, ElifToken.getLocation()); } @ 1.1.1.4.4.1 log @file PPDirectives.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:28 +0000 @ text @d1 2343 @ 1.1.1.4.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 2343 //===--- PPDirectives.cpp - Directive Handling for Preprocessor -----------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// /// /// \file /// \brief Implements # directive processing for the Preprocessor. /// //===----------------------------------------------------------------------===// #include "clang/Lex/Preprocessor.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/SourceManager.h" #include "clang/Lex/CodeCompletionHandler.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/HeaderSearchOptions.h" #include "clang/Lex/LexDiagnostic.h" #include "clang/Lex/LiteralSupport.h" #include "clang/Lex/MacroInfo.h" #include "clang/Lex/ModuleLoader.h" #include "clang/Lex/Pragma.h" #include "llvm/ADT/APInt.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/SaveAndRestore.h" using namespace clang; //===----------------------------------------------------------------------===// // Utility Methods for Preprocessor Directive Handling. //===----------------------------------------------------------------------===// MacroInfo *Preprocessor::AllocateMacroInfo() { MacroInfoChain *MIChain; if (MICache) { MIChain = MICache; MICache = MICache->Next; } else { MIChain = BP.Allocate(); } MIChain->Next = MIChainHead; MIChain->Prev = 0; if (MIChainHead) MIChainHead->Prev = MIChain; MIChainHead = MIChain; return &(MIChain->MI); } MacroInfo *Preprocessor::AllocateMacroInfo(SourceLocation L) { MacroInfo *MI = AllocateMacroInfo(); new (MI) MacroInfo(L); return MI; } MacroInfo *Preprocessor::AllocateDeserializedMacroInfo(SourceLocation L, unsigned SubModuleID) { LLVM_STATIC_ASSERT(llvm::AlignOf::Alignment >= sizeof(SubModuleID), "alignment for MacroInfo is less than the ID"); DeserializedMacroInfoChain *MIChain = BP.Allocate(); MIChain->Next = DeserialMIChainHead; DeserialMIChainHead = MIChain; MacroInfo *MI = &MIChain->MI; new (MI) MacroInfo(L); MI->FromASTFile = true; MI->setOwningModuleID(SubModuleID); return MI; } DefMacroDirective * Preprocessor::AllocateDefMacroDirective(MacroInfo *MI, SourceLocation Loc, bool isImported) { DefMacroDirective *MD = BP.Allocate(); new (MD) DefMacroDirective(MI, Loc, isImported); return MD; } UndefMacroDirective * Preprocessor::AllocateUndefMacroDirective(SourceLocation UndefLoc) { UndefMacroDirective *MD = BP.Allocate(); new (MD) UndefMacroDirective(UndefLoc); return MD; } VisibilityMacroDirective * Preprocessor::AllocateVisibilityMacroDirective(SourceLocation Loc, bool isPublic) { VisibilityMacroDirective *MD = BP.Allocate(); new (MD) VisibilityMacroDirective(Loc, isPublic); return MD; } /// \brief Release the specified MacroInfo to be reused for allocating /// new MacroInfo objects. void Preprocessor::ReleaseMacroInfo(MacroInfo *MI) { MacroInfoChain *MIChain = (MacroInfoChain*) MI; if (MacroInfoChain *Prev = MIChain->Prev) { MacroInfoChain *Next = MIChain->Next; Prev->Next = Next; if (Next) Next->Prev = Prev; } else { assert(MIChainHead == MIChain); MIChainHead = MIChain->Next; MIChainHead->Prev = 0; } MIChain->Next = MICache; MICache = MIChain; MI->Destroy(); } /// \brief Read and discard all tokens remaining on the current line until /// the tok::eod token is found. void Preprocessor::DiscardUntilEndOfDirective() { Token Tmp; do { LexUnexpandedToken(Tmp); assert(Tmp.isNot(tok::eof) && "EOF seen while discarding directive tokens"); } while (Tmp.isNot(tok::eod)); } /// \brief Lex and validate a macro name, which occurs after a /// \#define or \#undef. /// /// This sets the token kind to eod and discards the rest /// of the macro line if the macro name is invalid. \p isDefineUndef is 1 if /// this is due to a a \#define, 2 if \#undef directive, 0 if it is something /// else (e.g. \#ifdef). void Preprocessor::ReadMacroName(Token &MacroNameTok, char isDefineUndef) { // Read the token, don't allow macro expansion on it. LexUnexpandedToken(MacroNameTok); if (MacroNameTok.is(tok::code_completion)) { if (CodeComplete) CodeComplete->CodeCompleteMacroName(isDefineUndef == 1); setCodeCompletionReached(); LexUnexpandedToken(MacroNameTok); } // Missing macro name? if (MacroNameTok.is(tok::eod)) { Diag(MacroNameTok, diag::err_pp_missing_macro_name); return; } IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); if (II == 0) { bool Invalid = false; std::string Spelling = getSpelling(MacroNameTok, &Invalid); if (Invalid) return; const IdentifierInfo &Info = Identifiers.get(Spelling); // Allow #defining |and| and friends in microsoft mode. if (Info.isCPlusPlusOperatorKeyword() && getLangOpts().MSVCCompat) { MacroNameTok.setIdentifierInfo(getIdentifierInfo(Spelling)); return; } if (Info.isCPlusPlusOperatorKeyword()) // C++ 2.5p2: Alternative tokens behave the same as its primary token // except for their spellings. Diag(MacroNameTok, diag::err_pp_operator_used_as_macro_name) << Spelling; else Diag(MacroNameTok, diag::err_pp_macro_not_identifier); // Fall through on error. } else if (isDefineUndef && II->getPPKeywordID() == tok::pp_defined) { // Error if defining "defined": C99 6.10.8/4, C++ [cpp.predefined]p4. Diag(MacroNameTok, diag::err_defined_macro_name); } else if (isDefineUndef == 2 && II->hasMacroDefinition() && getMacroInfo(II)->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); return; } else { // Okay, we got a good identifier node. Return it. return; } // Invalid macro name, read and discard the rest of the line. Then set the // token kind to tok::eod. MacroNameTok.setKind(tok::eod); return DiscardUntilEndOfDirective(); } /// \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 /// true, then we consider macros that expand to zero tokens as being ok. void Preprocessor::CheckEndOfDirective(const char *DirType, bool EnableMacros) { Token Tmp; // 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); // 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); if (Tmp.isNot(tok::eod)) { // Add a fixit in GNU/C99/C++ mode. Don't offer a fixit for strict-C89, // or if this is a macro-style preprocessing directive, because it is more // trouble than it is worth to insert /**/ and check that there is no /**/ // in the range also. FixItHint Hint; if ((LangOpts.GNUMode || LangOpts.C99 || LangOpts.CPlusPlus) && !CurTokenLexer) Hint = FixItHint::CreateInsertion(Tmp.getLocation(),"//"); Diag(Tmp, diag::ext_pp_extra_tokens_at_eol) << DirType << Hint; DiscardUntilEndOfDirective(); } } /// 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 /// FoundNonSkipPortion is true, then we have already emitted code for part of /// 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. void Preprocessor::SkipExcludedConditionalBlock(SourceLocation IfTokenLoc, bool FoundNonSkipPortion, bool FoundElse, SourceLocation ElseLoc) { ++NumSkipped; assert(!CurTokenLexer && CurPPLexer && "Lexing a macro, not a file?"); CurPPLexer->pushConditionalLevel(IfTokenLoc, /*isSkipping*/false, FoundNonSkipPortion, FoundElse); if (CurPTHLexer) { PTHSkipExcludedConditionalBlock(); return; } // Enter raw mode to disable identifier lookup (and thus macro expansion), // disabling warnings, etc. CurPPLexer->LexingRawMode = true; Token Tok; while (1) { CurLexer->Lex(Tok); if (Tok.is(tok::code_completion)) { if (CodeComplete) CodeComplete->CodeCompleteInConditionalExclusion(); setCodeCompletionReached(); continue; } // 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. while (!CurPPLexer->ConditionalStack.empty()) { if (CurLexer->getFileLoc() != CodeCompletionFileLoc) Diag(CurPPLexer->ConditionalStack.back().IfLoc, diag::err_pp_unterminated_conditional); CurPPLexer->ConditionalStack.pop_back(); } // Just return and let the caller lex after this #include. break; } // If this token is not a preprocessor directive, just skip it. if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine()) continue; // 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 EOD token (this terminates the macro). CurPPLexer->ParsingPreprocessorDirective = true; if (CurLexer) CurLexer->SetKeepWhitespaceMode(false); // Read the next token, the directive flavor. LexUnexpandedToken(Tok); // If this isn't an identifier directive (e.g. is "# 1\n" or "#\n", or // something bogus), skip it. if (Tok.isNot(tok::raw_identifier)) { CurPPLexer->ParsingPreprocessorDirective = false; // Restore comment saving mode. if (CurLexer) CurLexer->resetExtendedTokenMode(); 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. const char *RawCharData = Tok.getRawIdentifierData(); char FirstChar = RawCharData[0]; if (FirstChar >= 'a' && FirstChar <= 'z' && FirstChar != 'i' && FirstChar != 'e') { CurPPLexer->ParsingPreprocessorDirective = false; // Restore comment saving mode. if (CurLexer) CurLexer->resetExtendedTokenMode(); continue; } // Get the identifier name without trigraphs or embedded newlines. Note // that we can't use Tok.getIdentifierInfo() because its lookup is disabled // when skipping. char DirectiveBuf[20]; StringRef Directive; if (!Tok.needsCleaning() && Tok.getLength() < 20) { Directive = StringRef(RawCharData, Tok.getLength()); } else { std::string DirectiveStr = getSpelling(Tok); unsigned IdLen = DirectiveStr.size(); if (IdLen >= 20) { CurPPLexer->ParsingPreprocessorDirective = false; // Restore comment saving mode. if (CurLexer) CurLexer->resetExtendedTokenMode(); continue; } memcpy(DirectiveBuf, &DirectiveStr[0], IdLen); Directive = StringRef(DirectiveBuf, IdLen); } if (Directive.startswith("if")) { StringRef Sub = Directive.substr(2); if (Sub.empty() || // "if" Sub == "def" || // "ifdef" Sub == "ndef") { // "ifndef" // We know the entire #if/#ifdef/#ifndef block will be skipped, don't // bother parsing the condition. DiscardUntilEndOfDirective(); CurPPLexer->pushConditionalLevel(Tok.getLocation(), /*wasskipping*/true, /*foundnonskip*/false, /*foundelse*/false); } } else if (Directive[0] == 'e') { StringRef Sub = Directive.substr(1); if (Sub == "ndif") { // "endif" PPConditionalInfo CondInfo; CondInfo.WasSkipping = true; // Silence bogus warning. bool InCond = CurPPLexer->popConditionalLevel(CondInfo); (void)InCond; // Silence warning in no-asserts mode. assert(!InCond && "Can't be skipping if not in a conditional!"); // If we popped the outermost skipping block, we're done skipping! if (!CondInfo.WasSkipping) { // Restore the value of LexingRawMode so that trailing comments // are handled correctly, if we've reached the outermost block. CurPPLexer->LexingRawMode = false; CheckEndOfDirective("endif"); CurPPLexer->LexingRawMode = true; if (Callbacks) Callbacks->Endif(Tok.getLocation(), CondInfo.IfLoc); break; } else { DiscardUntilEndOfDirective(); } } else if (Sub == "lse") { // "else". // #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. PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel(); // If this is a #else with a #else before it, report the error. if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_else_after_else); // Note that we've seen a #else in this conditional. CondInfo.FoundElse = true; // 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; // Restore the value of LexingRawMode so that trailing comments // are handled correctly. CurPPLexer->LexingRawMode = false; CheckEndOfDirective("else"); CurPPLexer->LexingRawMode = true; if (Callbacks) Callbacks->Else(Tok.getLocation(), CondInfo.IfLoc); break; } else { DiscardUntilEndOfDirective(); // C99 6.10p4. } } else if (Sub == "lif") { // "elif". PPConditionalInfo &CondInfo = CurPPLexer->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); // 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 { const SourceLocation CondBegin = CurPPLexer->getSourceLocation(); // Restore the value of LexingRawMode so that identifiers are // looked up, etc, inside the #elif expression. assert(CurPPLexer->LexingRawMode && "We have to be skipping here!"); CurPPLexer->LexingRawMode = false; IdentifierInfo *IfNDefMacro = 0; const bool CondValue = EvaluateDirectiveExpression(IfNDefMacro); CurPPLexer->LexingRawMode = true; if (Callbacks) { const SourceLocation CondEnd = CurPPLexer->getSourceLocation(); Callbacks->Elif(Tok.getLocation(), SourceRange(CondBegin, CondEnd), (CondValue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False), CondInfo.IfLoc); } // If this condition is true, enter it! if (CondValue) { CondInfo.FoundNonSkip = true; break; } } } } CurPPLexer->ParsingPreprocessorDirective = false; // Restore comment saving mode. if (CurLexer) CurLexer->resetExtendedTokenMode(); } // 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. CurPPLexer->LexingRawMode = false; if (Callbacks) { SourceLocation BeginLoc = ElseLoc.isValid() ? ElseLoc : IfTokenLoc; Callbacks->SourceRangeSkipped(SourceRange(BeginLoc, Tok.getLocation())); } } void Preprocessor::PTHSkipExcludedConditionalBlock() { while (1) { assert(CurPTHLexer); assert(CurPTHLexer->LexingRawMode == false); // 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); (void)InCond; // Silence warning in no-asserts mode. assert(!InCond && "Can't be skipping if not in a conditional!"); break; } // We have reached a '#else' or '#elif'. Lex the next token to get // the directive flavor. Token Tok; LexUnexpandedToken(Tok); // 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; // If the #if block wasn't entered then enter the #else block now. if (!CondInfo.FoundNonSkip) { CondInfo.FoundNonSkip = true; // Scan until the eod token. CurPTHLexer->ParsingPreprocessorDirective = true; DiscardUntilEndOfDirective(); CurPTHLexer->ParsingPreprocessorDirective = false; break; } // Otherwise skip this block. continue; } 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); // If this is in a skipping block or if we're already handled this #if // block, don't bother parsing the condition. We just skip this block. if (CondInfo.FoundNonSkip) continue; // Evaluate the condition of the #elif. IdentifierInfo *IfNDefMacro = 0; 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. continue; } } Module *Preprocessor::getModuleForLocation(SourceLocation FilenameLoc) { ModuleMap &ModMap = HeaderInfo.getModuleMap(); if (SourceMgr.isInMainFile(FilenameLoc)) { if (Module *CurMod = getCurrentModule()) return CurMod; // Compiling a module. return HeaderInfo.getModuleMap().SourceModule; // Compiling a source. } // Try to determine the module of the include directive. // FIXME: Look into directly passing the FileEntry from LookupFile instead. FileID IDOfIncl = SourceMgr.getFileID(SourceMgr.getSpellingLoc(FilenameLoc)); if (const FileEntry *EntryOfIncl = SourceMgr.getFileEntryForID(IDOfIncl)) { // The include comes from a file. return ModMap.findModuleForHeader(EntryOfIncl).getModule(); } else { // The include does not come from a file, // so it is probably a module compilation. return getCurrentModule(); } } const FileEntry *Preprocessor::LookupFile( SourceLocation FilenameLoc, StringRef Filename, bool isAngled, const DirectoryLookup *FromDir, const DirectoryLookup *&CurDir, SmallVectorImpl *SearchPath, SmallVectorImpl *RelativePath, ModuleMap::KnownHeader *SuggestedModule, bool SkipCache) { // If the header lookup mechanism may be relative to the current inclusion // stack, record the parent #includes. SmallVector Includers; if (!FromDir) { FileID FID = getCurrentFileLexer()->getFileID(); const FileEntry *FileEnt = SourceMgr.getFileEntryForID(FID); // If there is no file entry associated with this file, it must be the // predefines 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) as if they came from the main file, this // affects file lookup etc. if (!FileEnt) FileEnt = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID()); if (FileEnt) Includers.push_back(FileEnt); // 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 if (LangOpts.MSVCCompat && !isAngled) { for (unsigned i = 0, e = IncludeMacroStack.size(); i != e; ++i) { IncludeStackInfo &ISEntry = IncludeMacroStack[e - i - 1]; if (IsFileLexer(ISEntry)) if ((FileEnt = SourceMgr.getFileEntryForID( ISEntry.ThePPLexer->getFileID()))) Includers.push_back(FileEnt); } } } // Do a standard file entry lookup. CurDir = CurDirLookup; const FileEntry *FE = HeaderInfo.LookupFile( Filename, FilenameLoc, isAngled, FromDir, CurDir, Includers, SearchPath, RelativePath, SuggestedModule, SkipCache); if (FE) { if (SuggestedModule) HeaderInfo.getModuleMap().diagnoseHeaderInclusion( getModuleForLocation(FilenameLoc), FilenameLoc, Filename, FE); return FE; } const FileEntry *CurFileEnt; // 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. if (IsFileLexer()) { if ((CurFileEnt = SourceMgr.getFileEntryForID(CurPPLexer->getFileID()))) if ((FE = HeaderInfo.LookupSubframeworkHeader(Filename, CurFileEnt, SearchPath, RelativePath, SuggestedModule))) return FE; } for (unsigned i = 0, e = IncludeMacroStack.size(); i != e; ++i) { IncludeStackInfo &ISEntry = IncludeMacroStack[e-i-1]; if (IsFileLexer(ISEntry)) { if ((CurFileEnt = SourceMgr.getFileEntryForID(ISEntry.ThePPLexer->getFileID()))) if ((FE = HeaderInfo.LookupSubframeworkHeader( Filename, CurFileEnt, SearchPath, RelativePath, SuggestedModule))) return FE; } } // Otherwise, we really couldn't find the file. return 0; } //===----------------------------------------------------------------------===// // Preprocessor Directive Handling. //===----------------------------------------------------------------------===// class Preprocessor::ResetMacroExpansionHelper { public: ResetMacroExpansionHelper(Preprocessor *pp) : PP(pp), save(pp->DisableMacroExpansion) { if (pp->MacroExpansionInDirectivesOverride) pp->DisableMacroExpansion = false; } ~ResetMacroExpansionHelper() { PP->DisableMacroExpansion = save; } private: Preprocessor *PP; bool save; }; /// HandleDirective - This callback is invoked when the lexer sees a # token /// at the start of a line. This consumes the directive, modifies the /// 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? // 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 // EOD token (which terminates the directive). CurPPLexer->ParsingPreprocessorDirective = true; if (CurLexer) CurLexer->SetKeepWhitespaceMode(false); bool ImmediatelyAfterTopLevelIfndef = CurPPLexer->MIOpt.getImmediatelyAfterTopLevelIfndef(); CurPPLexer->MIOpt.resetImmediatelyAfterTopLevelIfndef(); ++NumDirectives; // We are about to read a token. For the multiple-include optimization FA to // work, we have to remember if we had read any tokens *before* this // pp-directive. bool ReadAnyTokensBeforeDirective =CurPPLexer->MIOpt.getHasReadAnyTokensVal(); // Save the '#' token in case we need to return it later. Token SavedHash = Result; // Read the next token, the directive flavor. This isn't expanded due to // C99 6.10.3p8. LexUnexpandedToken(Result); // C99 6.10.3p11: Is this preprocessor directive in macro invocation? e.g.: // #define A(x) #x // A(abc // #warning blah // def) // 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: Diag(Result, diag::err_embedded_include) << II->getName(); DiscardUntilEndOfDirective(); return; default: break; } } Diag(Result, diag::ext_embedded_directive); } // Temporarily enable macro expansion if set so // and reset to previous state when returning from this function. ResetMacroExpansionHelper helper(this); switch (Result.getKind()) { case tok::eod: return; // null directive. case tok::code_completion: if (CodeComplete) CodeComplete->CodeCompleteDirective( CurPPLexer->getConditionalStackDepth() > 0); setCodeCompletionReached(); return; case tok::numeric_constant: // # 7 GNU line marker directive. if (getLangOpts().AsmPreprocessor) break; // # 4 is not a preprocessor directive in .S files. return HandleDigitDirective(Result); default: IdentifierInfo *II = Result.getIdentifierInfo(); if (II == 0) break; // Not an identifier. // 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); // C99 6.10.2 - Source File Inclusion. case tok::pp_include: // Handle #include. return HandleIncludeDirective(SavedHash.getLocation(), Result); case tok::pp___include_macros: // Handle -imacros. return HandleIncludeMacrosDirective(SavedHash.getLocation(), Result); // C99 6.10.3 - Macro Replacement. case tok::pp_define: return HandleDefineDirective(Result, ImmediatelyAfterTopLevelIfndef); case tok::pp_undef: return HandleUndefDirective(Result); // C99 6.10.4 - Line Control. case tok::pp_line: return HandleLineDirective(Result); // C99 6.10.5 - Error Directive. case tok::pp_error: return HandleUserDiagnosticDirective(Result, false); // C99 6.10.6 - Pragma Directive. case tok::pp_pragma: return HandlePragmaDirective(SavedHash.getLocation(), PIK_HashPragma); // GNU Extensions. case tok::pp_import: return HandleImportDirective(SavedHash.getLocation(), Result); case tok::pp_include_next: return HandleIncludeNextDirective(SavedHash.getLocation(), Result); 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; case tok::pp___public_macro: if (getLangOpts().Modules) return HandleMacroPublicDirective(Result); break; case tok::pp___private_macro: if (getLangOpts().Modules) return HandleMacroPrivateDirective(Result); break; } break; } // 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. if (getLangOpts().AsmPreprocessor) { Token *Toks = new Token[2]; // Return the # and the token after it. Toks[0] = SavedHash; Toks[1] = Result; // 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); // 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. EnterTokenStream(Toks, 2, false, true); return; } // If we reached here, the preprocessing token is not valid! Diag(Result, diag::err_pp_invalid_directive); // Read the rest of the PP line. DiscardUntilEndOfDirective(); // Okay, we're done parsing the directive. } /// 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, unsigned DiagID, Preprocessor &PP, bool IsGNULineDirective=false) { if (DigitTok.isNot(tok::numeric_constant)) { PP.Diag(DigitTok, DiagID); if (DigitTok.isNot(tok::eod)) PP.DiscardUntilEndOfDirective(); return true; } SmallString<64> IntegerBuffer; IntegerBuffer.resize(DigitTok.getLength()); const char *DigitTokBegin = &IntegerBuffer[0]; bool Invalid = false; unsigned ActualLength = PP.getSpelling(DigitTok, DigitTokBegin, &Invalid); if (Invalid) return true; // 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) { // C++1y [lex.fcon]p1: // Optional separating single quotes in a digit-sequence are ignored if (DigitTokBegin[i] == '\'') continue; if (!isDigit(DigitTokBegin[i])) { PP.Diag(PP.AdvanceToTokenCharacter(DigitTok.getLocation(), i), diag::err_pp_line_digit_sequence) << IsGNULineDirective; PP.DiscardUntilEndOfDirective(); return true; } unsigned NextVal = Val*10+(DigitTokBegin[i]-'0'); if (NextVal < Val) { // overflow. PP.Diag(DigitTok, DiagID); PP.DiscardUntilEndOfDirective(); return true; } Val = NextVal; } if (DigitTokBegin[0] == '0' && Val) PP.Diag(DigitTok.getLocation(), diag::warn_pp_line_decimal) << IsGNULineDirective; return false; } /// \brief Handle a \#line directive: C99 6.10.4. /// /// The two acceptable forms are: /// \verbatim /// # line digit-sequence /// # line digit-sequence "s-char-sequence" /// \endverbatim 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; if (GetLineValue(DigitTok, LineNo, diag::err_pp_line_requires_integer,*this)) return; if (LineNo == 0) Diag(DigitTok, diag::ext_pp_line_zero); // Enforce C99 6.10.4p3: "The digit sequence shall not specify ... a // number greater than 2147483647". C90 requires that the line # be <= 32767. unsigned LineLimit = 32768U; if (LangOpts.C99 || LangOpts.CPlusPlus11) LineLimit = 2147483648U; if (LineNo >= LineLimit) Diag(DigitTok, diag::ext_pp_line_too_big) << LineLimit; else if (LangOpts.CPlusPlus11 && LineNo >= 32768U) Diag(DigitTok, diag::warn_cxx98_compat_pp_line_too_big); int FilenameID = -1; Token StrTok; Lex(StrTok); // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a // string followed by eod. if (StrTok.is(tok::eod)) ; // ok else if (StrTok.isNot(tok::string_literal)) { Diag(StrTok, diag::err_pp_line_invalid_filename); return DiscardUntilEndOfDirective(); } else if (StrTok.hasUDSuffix()) { Diag(StrTok, diag::err_invalid_string_udl); return DiscardUntilEndOfDirective(); } else { // Parse and validate the string, converting it into a unique ID. StringLiteralParser Literal(&StrTok, 1, *this); assert(Literal.isAscii() && "Didn't allow wide strings in"); if (Literal.hadError) return DiscardUntilEndOfDirective(); if (Literal.Pascal) { Diag(StrTok, diag::err_pp_linemarker_invalid_filename); return DiscardUntilEndOfDirective(); } FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString()); // Verify that there is nothing after the string, other than EOD. Because // of C99 6.10.4p5, macros that expand to empty tokens are ok. CheckEndOfDirective("line", true); } SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID); if (Callbacks) Callbacks->FileChanged(CurPPLexer->getSourceLocation(), PPCallbacks::RenameFile, SrcMgr::C_User); } /// 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); if (FlagTok.is(tok::eod)) return false; if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP)) return true; if (FlagVal == 1) { IsFileEntry = true; PP.Lex(FlagTok); if (FlagTok.is(tok::eod)) return false; if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP)) return true; } else if (FlagVal == 2) { IsFileExit = true; 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 = SM.getDecomposedExpansionLoc(FlagTok.getLocation()).first; PresumedLoc PLoc = SM.getPresumedLoc(FlagTok.getLocation()); if (PLoc.isInvalid()) return true; // 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() || SM.getDecomposedExpansionLoc(IncLoc).first != CurFileID) { PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_pop); PP.DiscardUntilEndOfDirective(); return true; } PP.Lex(FlagTok); if (FlagTok.is(tok::eod)) return false; 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); PP.DiscardUntilEndOfDirective(); return true; } IsSystemHeader = true; PP.Lex(FlagTok); if (FlagTok.is(tok::eod)) return false; if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP)) return true; // We must have 4 if there is yet another flag. if (FlagVal != 4) { PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag); PP.DiscardUntilEndOfDirective(); return true; } IsExternCHeader = true; PP.Lex(FlagTok); if (FlagTok.is(tok::eod)) return false; // There are no more valid flags here. PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag); PP.DiscardUntilEndOfDirective(); return true; } /// HandleDigitDirective - Handle a GNU line marker directive, whose syntax is /// one of the following forms: /// /// # 42 /// # 42 "file" ('1' | '2')? /// # 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, *this, true)) return; Token StrTok; Lex(StrTok); bool IsFileEntry = false, IsFileExit = false; bool IsSystemHeader = false, IsExternCHeader = false; int FilenameID = -1; // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a // string followed by eod. if (StrTok.is(tok::eod)) ; // ok else if (StrTok.isNot(tok::string_literal)) { Diag(StrTok, diag::err_pp_linemarker_invalid_filename); return DiscardUntilEndOfDirective(); } else if (StrTok.hasUDSuffix()) { Diag(StrTok, diag::err_invalid_string_udl); return DiscardUntilEndOfDirective(); } else { // Parse and validate the string, converting it into a unique ID. StringLiteralParser Literal(&StrTok, 1, *this); assert(Literal.isAscii() && "Didn't allow wide strings in"); if (Literal.hadError) return DiscardUntilEndOfDirective(); if (Literal.Pascal) { Diag(StrTok, diag::err_pp_linemarker_invalid_filename); return DiscardUntilEndOfDirective(); } FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString()); // If a filename was present, read any flags that are present. if (ReadLineMarkerFlags(IsFileEntry, IsFileExit, IsSystemHeader, IsExternCHeader, *this)) return; } // Create a line note with this information. SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, IsFileEntry, IsFileExit, IsSystemHeader, IsExternCHeader); // 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; Callbacks->FileChanged(CurPPLexer->getSourceLocation(), Reason, FileKind); } } /// HandleUserDiagnosticDirective - Handle a #warning or #error directive. /// void Preprocessor::HandleUserDiagnosticDirective(Token &Tok, bool isWarning) { // PTH doesn't emit #warning or #error directives. if (CurPTHLexer) return CurPTHLexer->DiscardToEndOfLine(); // 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. SmallString<128> Message; CurLexer->ReadToEndOfLine(&Message); // Find the first non-whitespace character, so that we can make the // diagnostic more succinct. StringRef Msg = Message.str().ltrim(" "); if (isWarning) Diag(Tok, diag::pp_hash_warning) << Msg; else Diag(Tok, diag::err_pp_hash_error) << Msg; } /// HandleIdentSCCSDirective - Handle a #ident/#sccs directive. /// void Preprocessor::HandleIdentSCCSDirective(Token &Tok) { // Yes, this directive is an extension. Diag(Tok, diag::ext_pp_ident_directive); // Read the string argument. Token StrTok; Lex(StrTok); // If the token kind isn't a string, it's a malformed directive. if (StrTok.isNot(tok::string_literal) && StrTok.isNot(tok::wide_string_literal)) { Diag(StrTok, diag::err_pp_malformed_ident); if (StrTok.isNot(tok::eod)) DiscardUntilEndOfDirective(); return; } if (StrTok.hasUDSuffix()) { Diag(StrTok, diag::err_invalid_string_udl); return DiscardUntilEndOfDirective(); } // Verify that there is nothing after the string, other than EOD. CheckEndOfDirective("ident"); if (Callbacks) { bool Invalid = false; std::string Str = getSpelling(StrTok, &Invalid); if (!Invalid) Callbacks->Ident(Tok.getLocation(), Str); } } /// \brief Handle a #public directive. void Preprocessor::HandleMacroPublicDirective(Token &Tok) { Token MacroNameTok; ReadMacroName(MacroNameTok, 2); // Error reading macro name? If so, diagnostic already issued. if (MacroNameTok.is(tok::eod)) return; // Check to see if this is the last token on the #__public_macro line. CheckEndOfDirective("__public_macro"); IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); // Okay, we finally have a valid identifier to undef. MacroDirective *MD = getMacroDirective(II); // If the macro is not defined, this is an error. if (MD == 0) { Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II; return; } // Note that this macro has now been exported. appendMacroDirective(II, AllocateVisibilityMacroDirective( MacroNameTok.getLocation(), /*IsPublic=*/true)); } /// \brief Handle a #private directive. void Preprocessor::HandleMacroPrivateDirective(Token &Tok) { Token MacroNameTok; ReadMacroName(MacroNameTok, 2); // Error reading macro name? If so, diagnostic already issued. if (MacroNameTok.is(tok::eod)) return; // Check to see if this is the last token on the #__private_macro line. CheckEndOfDirective("__private_macro"); IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); // Okay, we finally have a valid identifier to undef. MacroDirective *MD = getMacroDirective(II); // If the macro is not defined, this is an error. if (MD == 0) { Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II; return; } // Note that this macro has now been marked private. appendMacroDirective(II, AllocateVisibilityMacroDirective( MacroNameTok.getLocation(), /*IsPublic=*/false)); } //===----------------------------------------------------------------------===// // Preprocessor Include Directive Handling. //===----------------------------------------------------------------------===// /// GetIncludeFilenameSpelling - Turn the specified lexer token into a fully /// checked and spelled filename, e.g. as an operand of \#include. This returns /// 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, StringRef &Buffer) { // Get the text form of the filename. assert(!Buffer.empty() && "Can't have tokens with empty spellings!"); // Make sure the filename is or "x". bool isAngled; if (Buffer[0] == '<') { if (Buffer.back() != '>') { Diag(Loc, diag::err_pp_expects_filename); Buffer = StringRef(); return true; } isAngled = true; } else if (Buffer[0] == '"') { if (Buffer.back() != '"') { Diag(Loc, diag::err_pp_expects_filename); Buffer = StringRef(); return true; } isAngled = false; } else { Diag(Loc, diag::err_pp_expects_filename); Buffer = StringRef(); return true; } // Diagnose #include "" as invalid. if (Buffer.size() <= 2) { Diag(Loc, diag::err_pp_empty_filename); Buffer = StringRef(); return true; } // Skip the brackets. Buffer = Buffer.substr(1, Buffer.size()-2); return isAngled; } // \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 // \#include FOO // \endcode // because in this case, "" 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, SourceLocation &End) { Token CurTok; Lex(CurTok); while (CurTok.isNot(tok::eod)) { End = CurTok.getLocation(); // FIXME: Provide code completion for #includes. if (CurTok.is(tok::code_completion)) { setCodeCompletionReached(); Lex(CurTok); continue; } // 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(' '); // Get the spelling of the token, directly into FilenameBuffer if possible. unsigned PreAppendSize = FilenameBuffer.size(); FilenameBuffer.resize(PreAppendSize+CurTok.getLength()); const char *BufPtr = &FilenameBuffer[PreAppendSize]; unsigned ActualLen = getSpelling(CurTok, BufPtr); // If the token was spelled somewhere else, copy it into FilenameBuffer. if (BufPtr != &FilenameBuffer[PreAppendSize]) memcpy(&FilenameBuffer[PreAppendSize], BufPtr, ActualLen); // Resize FilenameBuffer to the correct size. if (CurTok.getLength() != ActualLen) FilenameBuffer.resize(PreAppendSize+ActualLen); // If we found the '>' marker, return success. if (CurTok.is(tok::greater)) return false; Lex(CurTok); } // If we hit the eod marker, emit an error and return true so that the caller // knows the EOD has been read. Diag(CurTok.getLocation(), diag::err_pp_expects_filename); return true; } /// \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) { Token *Tok = new Token[1]; Tok[0].startToken(); Tok[0].setKind(Kind); Tok[0].setLocation(Begin); Tok[0].setAnnotationEndLoc(End); Tok[0].setAnnotationValue(AnnotationVal); PP.EnterTokenStream(Tok, 1, true, true); } /// 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 /// specifies the file to start searching from. void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc, Token &IncludeTok, const DirectoryLookup *LookupFrom, bool isImport) { Token FilenameTok; CurPPLexer->LexIncludeFilename(FilenameTok); // Reserve a buffer to get the spelling. SmallString<128> FilenameBuffer; StringRef Filename; SourceLocation End; SourceLocation CharEnd; // the end of this directive, in characters switch (FilenameTok.getKind()) { case tok::eod: // If the token kind is EOD, the error has already been diagnosed. return; case tok::angle_string_literal: case tok::string_literal: Filename = getSpelling(FilenameTok, FilenameBuffer); End = FilenameTok.getLocation(); CharEnd = End.getLocWithOffset(FilenameTok.getLength()); break; case tok::less: // This could be a file coming from a macro expansion. In this // case, glue the tokens together into FilenameBuffer and interpret those. FilenameBuffer.push_back('<'); if (ConcatenateIncludeName(FilenameBuffer, End)) return; // Found but no ">"? Diagnostic already emitted. Filename = FilenameBuffer.str(); CharEnd = End.getLocWithOffset(1); break; default: Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename); DiscardUntilEndOfDirective(); return; } CharSourceRange FilenameRange = CharSourceRange::getCharRange(FilenameTok.getLocation(), CharEnd); StringRef OriginalFilename = Filename; bool isAngled = GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename); // If GetIncludeFilenameSpelling set the start ptr to null, there was an // error. if (Filename.empty()) { DiscardUntilEndOfDirective(); return; } // Verify that there is nothing after the filename, other than EOD. Note that // we allow macros that expand to nothing after the filename, because this // falls into the category of "#include pp-tokens new-line" specified in // C99 6.10.2p4. CheckEndOfDirective(IncludeTok.getIdentifierInfo()->getNameStart(), true); // Check that we don't have infinite #include recursion. if (IncludeMacroStack.size() == MaxAllowedIncludeStackDepth-1) { Diag(FilenameTok, diag::err_pp_include_too_deep); return; } // 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(); } if (HeaderInfo.HasIncludeAliasMap()) { // 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 // spelling for. StringRef NewName = HeaderInfo.MapHeaderToIncludeAlias(OriginalFilename); if (!NewName.empty()) Filename = NewName; } // Search include directories. const DirectoryLookup *CurDir; SmallString<1024> SearchPath; SmallString<1024> RelativePath; // We get the raw path only if we have 'Callbacks' to which we later pass // the path. ModuleMap::KnownHeader SuggestedModule; SourceLocation FilenameLoc = FilenameTok.getLocation(); const FileEntry *File = LookupFile( FilenameLoc, Filename, isAngled, LookupFrom, CurDir, Callbacks ? &SearchPath : NULL, Callbacks ? &RelativePath : NULL, HeaderInfo.getHeaderSearchOpts().ModuleMaps ? &SuggestedModule : 0); if (Callbacks) { if (!File) { // Give the clients a chance to recover. SmallString<128> RecoveryPath; if (Callbacks->FileNotFound(Filename, RecoveryPath)) { if (const DirectoryEntry *DE = FileMgr.getDirectory(RecoveryPath)) { // Add the recovery path to the list of search paths. DirectoryLookup DL(DE, SrcMgr::C_User, false); HeaderInfo.AddSearchPath(DL, isAngled); // Try the lookup again, skipping the cache. File = LookupFile(FilenameLoc, Filename, isAngled, LookupFrom, CurDir, 0, 0, HeaderInfo.getHeaderSearchOpts().ModuleMaps ? &SuggestedModule : 0, /*SkipCache*/ true); } } } if (!SuggestedModule || !getLangOpts().Modules) { // Notify the callback object that we've seen an inclusion directive. Callbacks->InclusionDirective(HashLoc, IncludeTok, Filename, isAngled, FilenameRange, File, SearchPath, RelativePath, /*ImportedModule=*/0); } } if (File == 0) { if (!SuppressIncludeNotFoundError) { // If the file could not be located and it was included via angle // brackets, we can attempt a lookup as though it were a quoted path to // provide the user with a possible fixit. if (isAngled) { File = LookupFile( FilenameLoc, Filename, false, LookupFrom, CurDir, Callbacks ? &SearchPath : 0, Callbacks ? &RelativePath : 0, HeaderInfo.getHeaderSearchOpts().ModuleMaps ? &SuggestedModule : 0); if (File) { SourceRange Range(FilenameTok.getLocation(), CharEnd); Diag(FilenameTok, diag::err_pp_file_not_found_not_fatal) << Filename << FixItHint::CreateReplacement(Range, "\"" + Filename.str() + "\""); } } // If the file is still not found, just go with the vanilla diagnostic if (!File) Diag(FilenameTok, diag::err_pp_file_not_found) << Filename; } if (!File) return; } // If we are supposed to import a module rather than including the header, // do so now. if (SuggestedModule && getLangOpts().Modules) { // Compute the module access path corresponding to this module. // FIXME: Should we have a second loadModule() overload to avoid this // extra lookup step? SmallVector, 2> Path; for (Module *Mod = SuggestedModule.getModule(); Mod; Mod = Mod->Parent) Path.push_back(std::make_pair(getIdentifierInfo(Mod->Name), FilenameTok.getLocation())); std::reverse(Path.begin(), Path.end()); // Warn that we're replacing the include/import with a module import. SmallString<128> PathString; for (unsigned I = 0, N = Path.size(); I != N; ++I) { if (I) PathString += '.'; PathString += Path[I].first->getName(); } int IncludeKind = 0; switch (IncludeTok.getIdentifierInfo()->getPPKeywordID()) { case tok::pp_include: IncludeKind = 0; break; case tok::pp_import: IncludeKind = 1; break; case tok::pp_include_next: IncludeKind = 2; break; case tok::pp___include_macros: IncludeKind = 3; break; default: llvm_unreachable("unknown include directive kind"); } // Determine whether we are actually building the module that this // include directive maps to. bool BuildingImportedModule = Path[0].first->getName() == getLangOpts().CurrentModule; if (!BuildingImportedModule && getLangOpts().ObjC2) { // If we're not building the imported module, warn that we're going // to automatically turn this inclusion directive into a module import. // We only do this in Objective-C, where we have a module-import syntax. CharSourceRange ReplaceRange(SourceRange(HashLoc, CharEnd), /*IsTokenRange=*/false); Diag(HashLoc, diag::warn_auto_module_import) << IncludeKind << PathString << FixItHint::CreateReplacement(ReplaceRange, "@@import " + PathString.str().str() + ";"); } // Load the module. Only make macros visible. We'll make the declarations // visible when the parser gets here. Module::NameVisibilityKind Visibility = Module::MacrosVisible; ModuleLoadResult Imported = TheModuleLoader.loadModule(IncludeTok.getLocation(), Path, Visibility, /*IsIncludeDirective=*/true); assert((Imported == 0 || Imported == SuggestedModule.getModule()) && "the imported module is different than the suggested one"); if (!Imported && 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); } return; } // If this header isn't part of the module we're building, we're done. if (!BuildingImportedModule && Imported) { if (Callbacks) { Callbacks->InclusionDirective(HashLoc, IncludeTok, Filename, isAngled, FilenameRange, File, SearchPath, RelativePath, Imported); } if (IncludeKind != 3) { // Let the parser know that we hit a module import, and it should // make the module visible. // FIXME: Produce this as the current token directly, rather than // allocating a new token for it. EnterAnnotationToken(*this, HashLoc, End, tok::annot_module_include, Imported); } return; } // If we failed to find a submodule that we expected to find, we can // continue. Otherwise, there's an error in the included file, so we // don't want to include it. if (!BuildingImportedModule && !Imported.isMissingExpected()) { return; } } if (Callbacks && SuggestedModule) { // We didn't notify the callback object that we've seen an inclusion // directive before. Now that we are parsing the include normally and not // turning it to a module import, notify the callback object. Callbacks->InclusionDirective(HashLoc, IncludeTok, Filename, isAngled, FilenameRange, File, SearchPath, RelativePath, /*ImportedModule=*/0); } // The #included file will be considered to be a system header if either it is // in a system include directory, or if the #includer is a system include // header. SrcMgr::CharacteristicKind FileCharacter = std::max(HeaderInfo.getFileDirFlavor(File), SourceMgr.getFileCharacteristic(FilenameTok.getLocation())); // Ask HeaderInfo if we should enter this #include file. If not, #including // this file will have no effect. if (!HeaderInfo.ShouldEnterIncludeFile(File, isImport)) { if (Callbacks) Callbacks->FileSkipped(*File, FilenameTok, FileCharacter); return; } // Look up the file, create a File ID for it. 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); assert(!FID.isInvalid() && "Expected valid file ID"); // Determine if we're switching to building a new submodule, and which one. ModuleMap::KnownHeader BuildingModule; if (getLangOpts().Modules && !getLangOpts().CurrentModule.empty()) { Module *RequestingModule = getModuleForLocation(FilenameLoc); BuildingModule = HeaderInfo.getModuleMap().findModuleForHeader(File, RequestingModule); } // If all is good, enter the new file! if (EnterSourceFile(FID, CurDir, FilenameTok.getLocation())) return; // If we're walking into another part of the same module, let the parser // know that any future declarations are within that other submodule. if (BuildingModule) { assert(!CurSubmodule && "should not have marked this as a module yet"); CurSubmodule = BuildingModule.getModule(); EnterAnnotationToken(*this, HashLoc, End, tok::annot_module_begin, CurSubmodule); } } /// HandleIncludeNextDirective - Implements \#include_next. /// void Preprocessor::HandleIncludeNextDirective(SourceLocation HashLoc, Token &IncludeNextTok) { Diag(IncludeNextTok, diag::ext_pp_include_next_directive); // #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; if (isInPrimaryFile()) { Lookup = 0; Diag(IncludeNextTok, diag::pp_include_next_in_primary); } else if (Lookup == 0) { Diag(IncludeNextTok, diag::pp_include_next_absolute_path); } else { // Start looking up in the next directory. ++Lookup; } return HandleIncludeDirective(HashLoc, IncludeNextTok, Lookup); } /// HandleMicrosoftImportDirective - Implements \#import for Microsoft Mode 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 ); // Read tokens until we get to the end of the directive. Note that the // directive can be split over multiple lines using the backslash character. DiscardUntilEndOfDirective(); } /// HandleImportDirective - Implements \#import. /// void Preprocessor::HandleImportDirective(SourceLocation HashLoc, Token &ImportTok) { if (!LangOpts.ObjC1) { // #import is standard for ObjC. if (LangOpts.MSVCCompat) return HandleMicrosoftImportDirective(ImportTok); Diag(ImportTok, diag::ext_pp_import_directive); } return HandleIncludeDirective(HashLoc, ImportTok, 0, true); } /// 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). void Preprocessor::HandleIncludeMacrosDirective(SourceLocation HashLoc, Token &IncludeMacrosTok) { // 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), "") != 0) { Diag(IncludeMacrosTok.getLocation(), diag::pp_include_macros_out_of_predefines); DiscardUntilEndOfDirective(); return; } // Treat this as a normal #include for checking purposes. If this is // successful, it will push a new lexer onto the include stack. HandleIncludeDirective(HashLoc, IncludeMacrosTok, 0, false); Token TmpTok; do { Lex(TmpTok); assert(TmpTok.isNot(tok::eof) && "Didn't find end of -imacros!"); } while (TmpTok.isNot(tok::hashhash)); } //===----------------------------------------------------------------------===// // 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. bool Preprocessor::ReadMacroDefinitionArgList(MacroInfo *MI, Token &Tok) { SmallVector Arguments; while (1) { LexUnexpandedToken(Tok); switch (Tok.getKind()) { case tok::r_paren: // Found the end of the argument list. if (Arguments.empty()) // #define FOO() 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 if (!LangOpts.C99) Diag(Tok, LangOpts.CPlusPlus11 ? diag::warn_cxx98_compat_variadic_macro : diag::ext_variadic_macro); // OpenCL v1.2 s6.9.e: variadic macros are not supported. if (LangOpts.OpenCL) { Diag(Tok, diag::err_pp_opencl_variadic_macros); return true; } // 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(); MI->setArgumentList(&Arguments[0], Arguments.size(), BP); return false; case tok::eod: // #define X( 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(); if (II == 0) { // #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. if (std::find(Arguments.begin(), Arguments.end(), II) != Arguments.end()) { // C99 6.10.3p6 Diag(Tok, diag::err_pp_duplicate_name_in_arg_list) << II; return true; } // Add the argument to the macro info. Arguments.push_back(II); // Lex the token after the identifier. LexUnexpandedToken(Tok); 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) MI->setArgumentList(&Arguments[0], Arguments.size(), BP); 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); // 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; } MI->setIsGNUVarargs(); MI->setArgumentList(&Arguments[0], Arguments.size(), BP); return false; } } } } /// HandleDefineDirective - Implements \#define. This consumes the entire macro /// line then lets the caller lex the next real token. void Preprocessor::HandleDefineDirective(Token &DefineTok, bool ImmediatelyAfterHeaderGuard) { ++NumDefined; Token MacroNameTok; ReadMacroName(MacroNameTok, 1); // Error reading macro name? If so, diagnostic already issued. if (MacroNameTok.is(tok::eod)) return; Token LastTok = MacroNameTok; // If we are supposed to keep comments in #defines, reenable comment saving // mode. if (CurLexer) CurLexer->SetCommentRetentionState(KeepMacroComments); // Create the new macro. MacroInfo *MI = AllocateMacroInfo(MacroNameTok.getLocation()); Token Tok; LexUnexpandedToken(Tok); // 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. if (Tok.is(tok::eod)) { if (ImmediatelyAfterHeaderGuard) { // Save this macro information since it may part of a header guard. CurPPLexer->MIOpt.SetDefinedMacro(MacroNameTok.getIdentifierInfo(), MacroNameTok.getLocation()); } // If there is no body to this macro, we have no special handling here. } 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)) { // This is a function-like macro definition. Read the argument list. MI->setIsFunctionLike(); if (ReadMacroDefinitionArgList(MI, LastTok)) { // Forget about MI. ReleaseMacroInfo(MI); // Throw away the rest of the line. if (CurPPLexer->ParsingPreprocessorDirective) DiscardUntilEndOfDirective(); return; } // If this is a definition of a variadic C99 function-like macro, not using // the GNU named varargs extension, enabled __VA_ARGS__. // "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); // Read the first token after the arg list for down below. LexUnexpandedToken(Tok); } else if (LangOpts.C99 || LangOpts.CPlusPlus11) { // C99 requires whitespace between the macro definition and the body. Emit // a diagnostic for something like "#define X+". Diag(Tok, diag::ext_c99_whitespace_required_after_macro_name); } else { // 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); } if (!Tok.is(tok::eod)) LastTok = Tok; // Read the rest of the macro body. if (MI->isObjectLike()) { // Object-like macros are very simple, just read their body. while (Tok.isNot(tok::eod)) { LastTok = Tok; MI->AddTokenToBody(Tok); // Get the next token of the macro. LexUnexpandedToken(Tok); } } else { // 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. while (Tok.isNot(tok::eod)) { LastTok = Tok; if (Tok.isNot(tok::hash) && Tok.isNot(tok::hashhash)) { MI->AddTokenToBody(Tok); // Get the next token of the macro. LexUnexpandedToken(Tok); continue; } // 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; } 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. // 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(); // Things look ok, add the '##' token to the macro. MI->AddTokenToBody(LastTok); continue; } // Get the next token of the macro. LexUnexpandedToken(Tok); // Check for a valid macro arg identifier. if (Tok.getIdentifierInfo() == 0 || 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. if (getLangOpts().AsmPreprocessor && Tok.isNot(tok::eod)) { LastTok.setKind(tok::unknown); MI->AddTokenToBody(LastTok); continue; } else { Diag(Tok, diag::err_pp_stringize_not_parameter); ReleaseMacroInfo(MI); // Disable __VA_ARGS__ again. Ident__VA_ARGS__->setIsPoisoned(true); return; } } // Things look ok, add the '#' and param name tokens to the macro. MI->AddTokenToBody(LastTok); MI->AddTokenToBody(Tok); LastTok = Tok; // Get the next token of the macro. LexUnexpandedToken(Tok); } } // Disable __VA_ARGS__ again. Ident__VA_ARGS__->setIsPoisoned(true); // Check that there is no paste (##) operator at the beginning or end of the // 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); ReleaseMacroInfo(MI); return; } if (MI->getReplacementToken(NumTokens-1).is(tok::hashhash)) { Diag(MI->getReplacementToken(NumTokens-1), diag::err_paste_at_end); ReleaseMacroInfo(MI); return; } } MI->setDefinitionEndLoc(LastTok.getLocation()); // Finally, if this identifier already had a macro defined for it, verify that // the macro bodies are identical, and issue diagnostics if they are not. if (const MacroInfo *OtherMI=getMacroInfo(MacroNameTok.getIdentifierInfo())) { // 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. if (!getDiagnostics().getSuppressSystemWarnings() || !SourceMgr.isInSystemHeader(DefineTok.getLocation())) { if (!OtherMI->isUsed() && OtherMI->isWarnIfUnused()) Diag(OtherMI->getDefinitionLoc(), diag::pp_macro_not_used); // Warn if defining "__LINE__" and other builtins, per C99 6.10.8/4 and // C++ [cpp.predefined]p4, but allow it as an extension. if (OtherMI->isBuiltinMacro()) Diag(MacroNameTok, diag::ext_pp_redef_builtin_macro); // Macros must be identical. This means all tokens and whitespace // separation must be the same. C99 6.10.3p2. else if (!OtherMI->isAllowRedefinitionsWithoutWarning() && !MI->isIdenticalTo(*OtherMI, *this, /*Syntactic=*/LangOpts.MicrosoftExt)) { Diag(MI->getDefinitionLoc(), diag::ext_pp_macro_redef) << MacroNameTok.getIdentifierInfo(); Diag(OtherMI->getDefinitionLoc(), diag::note_previous_definition); } } if (OtherMI->isWarnIfUnused()) WarnUnusedMacroLocs.erase(OtherMI->getDefinitionLoc()); } DefMacroDirective *MD = appendDefMacroDirective(MacroNameTok.getIdentifierInfo(), MI); 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. if (getSourceManager().isInMainFile(MI->getDefinitionLoc()) && Diags->getDiagnosticLevel(diag::pp_macro_not_used, MI->getDefinitionLoc()) != DiagnosticsEngine::Ignored) { MI->setIsWarnIfUnused(true); WarnUnusedMacroLocs.insert(MI->getDefinitionLoc()); } // If the callbacks want to know, tell them about the macro definition. if (Callbacks) Callbacks->MacroDefined(MacroNameTok, MD); } /// HandleUndefDirective - Implements \#undef. /// void Preprocessor::HandleUndefDirective(Token &UndefTok) { ++NumUndefined; Token MacroNameTok; ReadMacroName(MacroNameTok, 2); // Error reading macro name? If so, diagnostic already issued. if (MacroNameTok.is(tok::eod)) return; // Check to see if this is the last token on the #undef line. CheckEndOfDirective("undef"); // Okay, we finally have a valid identifier to undef. MacroDirective *MD = getMacroDirective(MacroNameTok.getIdentifierInfo()); const MacroInfo *MI = MD ? MD->getMacroInfo() : 0; // If the callbacks want to know, tell them about the macro #undef. // Note: no matter if the macro was defined or not. if (Callbacks) Callbacks->MacroUndefined(MacroNameTok, MD); // If the macro is not defined, this is a noop undef, just return. if (MI == 0) return; if (!MI->isUsed() && MI->isWarnIfUnused()) Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used); if (MI->isWarnIfUnused()) WarnUnusedMacroLocs.erase(MI->getDefinitionLoc()); appendMacroDirective(MacroNameTok.getIdentifierInfo(), AllocateUndefMacroDirective(MacroNameTok.getLocation())); } //===----------------------------------------------------------------------===// // Preprocessor Conditional Directive Handling. //===----------------------------------------------------------------------===// /// 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. /// void Preprocessor::HandleIfdefDirective(Token &Result, bool isIfndef, bool ReadAnyTokensBeforeDirective) { ++NumIf; Token DirectiveTok = Result; Token MacroNameTok; ReadMacroName(MacroNameTok); // Error reading macro name? If so, diagnostic already issued. if (MacroNameTok.is(tok::eod)) { // 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; } // Check to see if this is the last token on the #if[n]def line. CheckEndOfDirective(isIfndef ? "ifndef" : "ifdef"); IdentifierInfo *MII = MacroNameTok.getIdentifierInfo(); MacroDirective *MD = getMacroDirective(MII); MacroInfo *MI = MD ? MD->getMacroInfo() : 0; if (CurPPLexer->getConditionalStackDepth() == 0) { // 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. if (!ReadAnyTokensBeforeDirective && MI == 0) { assert(isIfndef && "#ifdef shouldn't reach here"); CurPPLexer->MIOpt.EnterTopLevelIfndef(MII, MacroNameTok.getLocation()); } else CurPPLexer->MIOpt.EnterTopLevelConditional(); } // If there is a macro, process it. if (MI) // Mark it used. markMacroAsUsed(MI); if (Callbacks) { if (isIfndef) Callbacks->Ifndef(DirectiveTok.getLocation(), MacroNameTok, MD); else Callbacks->Ifdef(DirectiveTok.getLocation(), MacroNameTok, MD); } // 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. CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(), /*wasskip*/false, /*foundnonskip*/true, /*foundelse*/false); } else { // No, skip the contents of this block. SkipExcludedConditionalBlock(DirectiveTok.getLocation(), /*Foundnonskip*/false, /*FoundElse*/false); } } /// HandleIfDirective - Implements the \#if directive. /// void Preprocessor::HandleIfDirective(Token &IfToken, bool ReadAnyTokensBeforeDirective) { ++NumIf; // Parse and evaluate the conditional expression. IdentifierInfo *IfNDefMacro = 0; const SourceLocation ConditionalBegin = CurPPLexer->getSourceLocation(); const bool ConditionalTrue = EvaluateDirectiveExpression(IfNDefMacro); const SourceLocation ConditionalEnd = CurPPLexer->getSourceLocation(); // If this condition is equivalent to #ifndef X, and if this is the first // directive seen, handle it for the multiple-include optimization. if (CurPPLexer->getConditionalStackDepth() == 0) { if (!ReadAnyTokensBeforeDirective && IfNDefMacro && ConditionalTrue) // FIXME: Pass in the location of the macro name, not the 'if' token. CurPPLexer->MIOpt.EnterTopLevelIfndef(IfNDefMacro, IfToken.getLocation()); else CurPPLexer->MIOpt.EnterTopLevelConditional(); } if (Callbacks) Callbacks->If(IfToken.getLocation(), SourceRange(ConditionalBegin, ConditionalEnd), (ConditionalTrue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False)); // Should we include the stuff contained by this directive? if (ConditionalTrue) { // Yes, remember that we are inside a conditional, then lex the next token. CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false, /*foundnonskip*/true, /*foundelse*/false); } else { // No, skip the contents of this block. SkipExcludedConditionalBlock(IfToken.getLocation(), /*Foundnonskip*/false, /*FoundElse*/false); } } /// HandleEndifDirective - Implements the \#endif directive. /// void Preprocessor::HandleEndifDirective(Token &EndifToken) { ++NumEndif; // Check that this is the whole directive. CheckEndOfDirective("endif"); PPConditionalInfo CondInfo; if (CurPPLexer->popConditionalLevel(CondInfo)) { // No conditionals on the stack: this is an #endif without an #if. Diag(EndifToken, diag::err_pp_endif_without_if); return; } // If this the end of a top-level #endif, inform MIOpt. if (CurPPLexer->getConditionalStackDepth() == 0) CurPPLexer->MIOpt.ExitTopLevelConditional(); assert(!CondInfo.WasSkipping && !CurPPLexer->LexingRawMode && "This code should only be reachable in the non-skipping case!"); if (Callbacks) Callbacks->Endif(EndifToken.getLocation(), CondInfo.IfLoc); } /// HandleElseDirective - Implements the \#else directive. /// void Preprocessor::HandleElseDirective(Token &Result) { ++NumElse; // #else directive in a non-skipping conditional... start skipping. CheckEndOfDirective("else"); PPConditionalInfo CI; if (CurPPLexer->popConditionalLevel(CI)) { Diag(Result, diag::pp_err_else_without_if); return; } // If this is a top-level #else, inform the MIOpt. if (CurPPLexer->getConditionalStackDepth() == 0) CurPPLexer->MIOpt.EnterTopLevelConditional(); // If this is a #else with a #else before it, report the error. if (CI.FoundElse) Diag(Result, diag::pp_err_else_after_else); if (Callbacks) Callbacks->Else(Result.getLocation(), CI.IfLoc); // Finally, skip the rest of the contents of this block. SkipExcludedConditionalBlock(CI.IfLoc, /*Foundnonskip*/true, /*FoundElse*/true, Result.getLocation()); } /// HandleElifDirective - Implements the \#elif directive. /// void Preprocessor::HandleElifDirective(Token &ElifToken) { ++NumElse; // #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). const SourceLocation ConditionalBegin = CurPPLexer->getSourceLocation(); DiscardUntilEndOfDirective(); const SourceLocation ConditionalEnd = CurPPLexer->getSourceLocation(); PPConditionalInfo CI; if (CurPPLexer->popConditionalLevel(CI)) { Diag(ElifToken, diag::pp_err_elif_without_if); return; } // If this is a top-level #elif, inform the MIOpt. if (CurPPLexer->getConditionalStackDepth() == 0) CurPPLexer->MIOpt.EnterTopLevelConditional(); // If this is a #elif with a #else before it, report the error. if (CI.FoundElse) Diag(ElifToken, diag::pp_err_elif_after_else); if (Callbacks) Callbacks->Elif(ElifToken.getLocation(), SourceRange(ConditionalBegin, ConditionalEnd), PPCallbacks::CVK_NotEvaluated, CI.IfLoc); // Finally, skip the rest of the contents of this block. SkipExcludedConditionalBlock(CI.IfLoc, /*Foundnonskip*/true, /*FoundElse*/CI.FoundElse, ElifToken.getLocation()); } @