Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/PPDirectives_8cpp_source.html below:

clang: lib/Lex/PPDirectives.cpp Source File

;

(std::is_trivially_destructible_v<MacroInfo>,

);

Preprocessor::AllocateUndefMacroDirective(

UndefLoc) {

(Tmp.

(tok::eod)) {

assert(Tmp.

(tok::eof) &&

);

StringRef ReservedMacro[] = {

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

std::binary_search(std::begin(ReservedMacro), std::end(ReservedMacro),

StringRef MacroName) {

(MacroName.starts_with(

))

(MacroName ==

)

(MacroName.starts_with(

))

(Lang.CPlusPlus &&

(Lang.CPlusPlus11 && (

==

||

==

))

(::llvm::sys::path::begin(Include)->equals_insensitive(

))

MaxStdHeaderNameLen = 18u;

(Include.size() > MaxStdHeaderNameLen)

(

&Ch : LowerInclude) {

(

(Ch) > 0x7f)

(Ch >=

&& Ch <=

)

(::llvm::sys::path::is_separator(Ch))

llvm::StringSwitch<bool>(LowerInclude)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

)

.Cases(

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Case(

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

,

)

.Cases(

,

,

,

,

)

.Cases(

,

,

,

,

)

std::optional<StringRef>

(StringRef

: Candidates) {

(LHS.equals_insensitive(

)) {

Length = LHS.size();

MaxDist = Length < 3 ? Length - 1 : Length / 3;

std::optional<std::pair<StringRef, size_t>> SimilarStr;

(StringRef

: Candidates) {

CurDist = LHS.edit_distance(

,

);

(CurDist <= MaxDist) {

SimilarStr = {

, CurDist};

}

(CurDist < SimilarStr->second) {

SimilarStr = {

, CurDist};

SimilarStr->first;

(MacroNameTok.

(tok::eod))

(MacroNameTok, diag::err_pp_missing_macro_name);

(MacroNameTok, diag::err_pp_macro_not_identifier);

? diag::ext_pp_operator_used_as_macro_name

: diag::err_pp_operator_used_as_macro_name)

<< II << MacroNameTok.

();

(MacroNameTok, diag::err_defined_macro_name);

*ShadowFlag =

;

(SourceMgr.

(MacroNameLoc) !=

)) {

(isDefineUndef ==

)

(MacroNameTok, diag::warn_pp_macro_is_reserved_id);

(MacroNameTok, diag::warn_pp_macro_is_reserved_attribute_id)

Preprocessor::ReadMacroName(

&MacroNameTok,

isDefineUndef,

(MacroNameTok.

(tok::code_completion)) {

(MacroNameTok.

(tok::eod)) {

MacroNameTok.

(tok::eod);

(Tmp.

(tok::comment))

(Tmp.

(tok::eod))

((LangOpts.GNUMode || LangOpts.C99 || LangOpts.CPlusPlus) &&

(Tmp, diag::ext_pp_extra_tokens_at_eol) << DirType << Hint;

Preprocessor::SuggestTypoedDirective(

&Tok,

std::vector<StringRef> Candidates = {

,

,

,

,

,

(LangOpts.C23 || LangOpts.CPlusPlus23)

Candidates.insert(Candidates.end(), {

,

});

StringRef SuggValue = *Sugg;

(Tok, diag::warn_pp_invalid_directive) << 1 << SuggValue << Hint;

Preprocessor::SkipExcludedConditionalBlock(

HashTokenLoc,

FoundNonSkipPortion,

assert(!SkippingExcludedConditionalBlock &&

);

assert(!CurTokenLexer &&

);

assert(CurPPLexer &&

);

assert(CurLexer &&

);

(PreambleConditionalStack.reachedEOFWhileSkipping())

PreambleConditionalStack.clearSkipInfo();

FoundNonSkipPortion, FoundElse);

SkippingRangeStateTy {

*BeginPtr =

;

*SkipRangePtr =

;

beginLexPass() {

BeginPtr = PP.CurLexer->getBufferLocation();

SkipRangePtr = &PP.RecordedSkippedRanges[BeginPtr];

PP.CurLexer->seek(PP.CurLexer->getCurrentBufferOffset() + *SkipRangePtr,

endLexPass(

*Hashptr) {

assert(PP.CurLexer->isDependencyDirectivesLexer());

(!*SkipRangePtr) {

*SkipRangePtr = Hashptr - BeginPtr;

assert(*SkipRangePtr ==

(Hashptr - BeginPtr));

SkipRangePtr =

;

} SkippingRangeState(*

);

(CurLexer->isDependencyDirectivesLexer()) {

CurLexer->LexDependencyDirectiveTokenWhileSkipping(Tok);

SkippingRangeState.beginLexPass();

(Tok.

(tok::code_completion)) {

(Tok.

(tok::eof)) {

(PreambleConditionalStack.isRecording())

PreambleConditionalStack.SkipInfo.emplace(HashTokenLoc, IfTokenLoc,

(Tok.

(tok::eof))

(CurLexer) CurLexer->SetKeepWhitespaceMode(

);

assert(Tok.

(tok::hash));

*Hashptr = CurLexer->getBufferLocation() - Tok.

();

assert(CurLexer->getSourceLocation(Hashptr) == Tok.

());

(Tok.

(tok::raw_identifier)) {

(CurLexer) CurLexer->resetExtendedTokenMode();

FirstChar = RI[0];

(FirstChar >=

&& FirstChar <=

&&

FirstChar !=

&& FirstChar !=

) {

(CurLexer) CurLexer->resetExtendedTokenMode();

DirectiveBuf[20];

IdLen = DirectiveStr.size();

(CurLexer) CurLexer->resetExtendedTokenMode();

(DirectiveBuf, &DirectiveStr[0], IdLen);

= StringRef(DirectiveBuf, IdLen);

(Sub ==

) {

assert(!InCond &&

);

SkippingRangeState.endLexPass(Hashptr);

}

(Sub ==

) {

SkippingRangeState.endLexPass(Hashptr);

(Tok, diag::pp_err_else_after_else);

}

(Sub ==

) {

SkippingRangeState.endLexPass(Hashptr);

assert(CurPPLexer->

&&

);

DirectiveEvalResult DER = EvaluateDirectiveExpression(IfNDefMacro);

CondValue = DER.Conditional;

}

(Sub ==

||

IsElifDef =

==

;

DirectiveToken = Tok;

SkippingRangeState.endLexPass(Hashptr);

(LangOpts.CPlusPlus)

DiagID = LangOpts.CPlusPlus23 ? diag::warn_cxx23_compat_pp_directive

: diag::ext_cxx23_pp_directive;

DiagID = LangOpts.C23 ? diag::warn_c23_compat_pp_directive

: diag::ext_c23_pp_directive;

(Tok, diag::pp_err_elif_after_else)

assert(CurPPLexer->

&&

);

ReadMacroName(MacroNameTok);

(MacroNameTok.

(tok::eod)) {

Callbacks->Elifdef(DirectiveToken.

(), MacroNameTok,

Callbacks->Elifndef(DirectiveToken.

(), MacroNameTok,

(

(MI) == IsElifDef) {

(CurLexer) CurLexer->resetExtendedTokenMode();

Callbacks->SourceRangeSkipped(

IncLoc, LangOpts.ModulesValidateTextualHeaderIncludes);

ID =

.getFileID(

.getExpansionLoc(

));

FE =

.getFileEntryRefForID(ID);

InPrivateHeader =

;

(!Header.isAccessibleFrom(IncM)) {

InPrivateHeader =

;

=

.getIncludeLoc(ID);

*IsFrameworkFound,

SkipCache,

OpenFile,

CacheFailures) {

FilenameLoc, LangOpts.ModulesValidateTextualHeaderIncludes);

BuildSystemModule =

;

(!FromDir && !FromFile) {

Includers.push_back(std::make_pair(std::nullopt, *IncludeDir));

Includers.push_back(std::make_pair(*FileEnt, *CWD));

Includers.push_back(std::make_pair(*FileEnt, FileEnt->

()));

(LangOpts.MSVCCompat && !isAngled) {

(IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) {

(IsFileLexer(ISEntry))

Includers.push_back(std::make_pair(*FileEnt, FileEnt->

()));

CurDir = CurDirLookup;

, FilenameLoc, isAngled, TmpFromDir, &TmpCurDir,

Includers, SearchPath, RelativePath, RequestingModule,

SuggestedModule,

,

, SkipCache)) {

TmpFromDir = TmpCurDir;

(&FE->getFileEntry() == FromFile) {

FromDir = TmpFromDir;

, FilenameLoc, isAngled, FromDir, &CurDir, Includers, SearchPath,

RelativePath, RequestingModule, SuggestedModule, IsMapped,

IsFrameworkFound, SkipCache, BuildSystemModule, OpenFile, CacheFailures);

(IsFileLexer()) {

, *CurFileEnt, SearchPath, RelativePath, RequestingModule,

(IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) {

(IsFileLexer(ISEntry)) {

((CurFileEnt = ISEntry.ThePPLexer->

())) {

, *CurFileEnt, SearchPath, RelativePath,

RequestingModule, SuggestedModule)) {

std::nullopt;

(llvm::sys::path::is_absolute(

)) {

, OpenFile,

,

);

llvm::expectedToOptional(std::move(ShouldBeEntry));

StringRef StartingFrom, StringRef

,

RemoveInitialFileComponentFromLookupPath) {

llvm::sys::path::native(StartingFrom, LookupPath);

(RemoveInitialFileComponentFromLookupPath)

llvm::sys::path::remove_filename(LookupPath);

(!LookupPath.empty() &&

!llvm::sys::path::is_separator(LookupPath.back())) {

LookupPath.push_back(llvm::sys::path::get_separator().front());

(LookupFromFile) {

(!FullFileDir.empty()) {

SeparateComponents(LookupPath, FullFileDir,

,

);

LookupPath, OpenFile,

,

);

llvm::expectedToOptional(std::move(ShouldBeEntry));

llvm::consumeError(ShouldBeEntry.takeError());

(MaybeWorkingDirEntry) {

StringRef WorkingDir = WorkingDirEntry.

();

(!WorkingDir.empty()) {

SeparateComponents(LookupPath, WorkingDir,

,

);

LookupPath, OpenFile,

,

);

llvm::expectedToOptional(std::move(ShouldBeEntry));

llvm::consumeError(ShouldBeEntry.takeError());

(

&Entry : PPOpts->EmbedEntries) {

SeparateComponents(LookupPath, Entry,

,

);

LookupPath, OpenFile,

,

);

llvm::expectedToOptional(std::move(ShouldBeEntry));

llvm::consumeError(ShouldBeEntry.takeError());

std::nullopt;

: PP(pp), save(pp->DisableMacroExpansion) {

(pp->MacroExpansionInDirectivesOverride)

pp->DisableMacroExpansion =

;

PP->DisableMacroExpansion = save;

(II->getPPKeywordID() == tok::pp_define) {

HandleDefineDirective(

,

(SkippingUntilPCHThroughHeader &&

II->getPPKeywordID() == tok::pp_include) {

HandleIncludeDirective(HashLoc,

);

(SkippingUntilPragmaHdrStop && II->getPPKeywordID() == tok::pp_pragma) {

*II =

.getIdentifierInfo();

(II && II->getName() ==

)

(CurLexer) CurLexer->SetKeepWhitespaceMode(

);

ImmediatelyAfterTopLevelIfndef =

(II->getPPKeywordID()) {

tok::pp_include:

tok::pp_import:

tok::pp_include_next:

tok::pp___include_macros:

tok::pp_pragma:

(

, diag::err_embedded_directive) << II->getName();

(*ArgMacro, diag::note_macro_expansion_here)

(

, diag::ext_embedded_directive);

(SkippingUntilPCHThroughHeader || SkippingUntilPragmaHdrStop)

(

.getKind()) {

tok::code_completion:

tok::numeric_constant:

HandleDigitDirective(

);

HandleIfDirective(

, SavedHash, ReadAnyTokensBeforeDirective);

HandleIfdefDirective(

, SavedHash,

,

tok::pp_ifndef:

HandleIfdefDirective(

, SavedHash,

,

ReadAnyTokensBeforeDirective);

tok::pp_elifdef:

tok::pp_elifndef:

HandleElseDirective(

, SavedHash);

HandleEndifDirective(

);

tok::pp_include:

tok::pp___include_macros:

tok::pp_define:

HandleDefineDirective(

, ImmediatelyAfterTopLevelIfndef);

HandleUndefDirective();

HandleLineDirective();

HandleUserDiagnosticDirective(

,

);

tok::pp_pragma:

tok::pp_import:

tok::pp_include_next:

tok::pp_warning:

(LangOpts.CPlusPlus)

? diag::warn_cxx23_compat_warning_directive

: diag::ext_pp_warning_directive)

(

, LangOpts.C23 ? diag::warn_c23_compat_warning_directive

: diag::ext_pp_warning_directive)

HandleUserDiagnosticDirective(

,

);

HandleIdentSCCSDirective(

);

HandleIdentSCCSDirective(

);

:

*

(

));

tok::pp_assert:

tok::pp_unassert:

tok::pp___public_macro:

HandleMacroPublicDirective(

);

tok::pp___private_macro:

HandleMacroPrivateDirective();

Toks = std::make_unique<Token[]>(2);

Toks[0] = SavedHash;

(

.is(tok::hashhash))

Toks[1].setKind(tok::unknown);

EnterTokenStream(std::move(Toks), 2,

,

);

(

, diag::err_pp_invalid_directive) << 0;

IsGNULineDirective=

) {

(DigitTok.

(tok::numeric_constant)) {

PP.

(DigitTok, DiagID);

(DigitTok.

(tok::eod))

IntegerBuffer.resize(DigitTok.

());

*DigitTokBegin = &IntegerBuffer[0];

(

i = 0; i != ActualLength; ++i) {

(DigitTokBegin[i] ==

)

(!

(DigitTokBegin[i])) {

diag::err_pp_line_digit_sequence) << IsGNULineDirective;

NextVal = Val*10+(DigitTokBegin[i]-

);

(NextVal < Val) {

PP.

(DigitTok, DiagID);

(DigitTokBegin[0] ==

&& Val)

<< IsGNULineDirective;

Preprocessor::HandleLineDirective() {

(

(DigitTok, LineNo, diag::err_pp_line_requires_integer,*

))

(DigitTok, diag::ext_pp_line_zero);

LineLimit = 32768U;

(LangOpts.C99 || LangOpts.CPlusPlus11)

LineLimit = 2147483648U;

(LineNo >= LineLimit)

(DigitTok, diag::ext_pp_line_too_big) << LineLimit;

(LangOpts.CPlusPlus11 && LineNo >= 32768U)

(DigitTok, diag::warn_cxx98_compat_pp_line_too_big);

FilenameID = -1;

(StrTok.

(tok::eod))

(StrTok.

(tok::string_literal)) {

(StrTok, diag::err_pp_line_invalid_filename);

(StrTok, diag::err_invalid_string_udl);

assert(

.isOrdinary() &&

);

(StrTok, diag::err_pp_linemarker_invalid_filename);

(FlagTok.

(tok::eod))

;

(

(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))

IsFileEntry =

;

(FlagTok.

(tok::eod))

;

(

(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP))

}

(FlagVal == 2) {

.getDecomposedExpansionLoc(FlagTok.

()).first;

.getDecomposedExpansionLoc(IncLoc).first != CurFileID) {

PP.

(FlagTok, diag::err_pp_linemarker_invalid_pop);

(FlagTok.

(tok::eod))

;

(

(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP))

PP.

(FlagTok, diag::err_pp_linemarker_invalid_flag);

(FlagTok.

(tok::eod))

;

(

(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))

PP.

(FlagTok, diag::err_pp_linemarker_invalid_flag);

(FlagTok.

(tok::eod))

;

PP.

(FlagTok, diag::err_pp_linemarker_invalid_flag);

Preprocessor::HandleDigitDirective(

&DigitTok) {

(

(DigitTok, LineNo, diag::err_pp_linemarker_requires_integer,

IsFileEntry =

, IsFileExit =

;

FilenameID = -1;

(StrTok.

(tok::eod)) {

(StrTok, diag::ext_pp_gnu_line_directive);

}

(StrTok.

(tok::string_literal)) {

(StrTok, diag::err_pp_linemarker_invalid_filename);

(StrTok, diag::err_invalid_string_udl);

assert(

.isOrdinary() &&

);

(StrTok, diag::err_pp_linemarker_invalid_filename);

(StrTok, diag::ext_pp_gnu_line_directive);

(!(IsFileExit &&

.GetString().empty()))

IsFileExit, FileKind);

(IsFileExit)

Preprocessor::HandleUserDiagnosticDirective(

&Tok,

CurLexer->ReadToEndOfLine(&Message);

StringRef Msg = Message.str().ltrim(

);

(Tok, diag::pp_hash_warning) << Msg;

(Tok, diag::err_pp_hash_error) << Msg;

Preprocessor::HandleIdentSCCSDirective(

&Tok) {

(Tok, diag::ext_pp_ident_directive);

(StrTok.

(tok::string_literal) &&

StrTok.

(tok::wide_string_literal)) {

(StrTok, diag::err_pp_malformed_ident);

(StrTok.

(tok::eod))

(StrTok, diag::err_invalid_string_udl);

Preprocessor::HandleMacroPublicDirective(

&Tok) {

ReadMacroName(MacroNameTok,

);

(MacroNameTok.

(tok::eod))

(MacroNameTok, diag::err_pp_visibility_non_macro) << II;

Preprocessor::HandleMacroPrivateDirective() {

ReadMacroName(MacroNameTok,

);

(MacroNameTok.

(tok::eod))

(MacroNameTok, diag::err_pp_visibility_non_macro) << II;

StringRef &Buffer) {

assert(!Buffer.empty() &&

);

(Buffer[0] ==

) {

(Buffer.back() !=

) {

(

, diag::err_pp_expects_filename);

Buffer = StringRef();

}

(Buffer[0] ==

) {

(Buffer.back() !=

) {

(

, diag::err_pp_expects_filename);

Buffer = StringRef();

(

, diag::err_pp_expects_filename);

Buffer = StringRef();

(Buffer.size() <= 2) {

(

, diag::err_pp_empty_filename);

Buffer = StringRef();

Buffer = Buffer.substr(1, Buffer.size()-2);

*AnnotationVal) {

Tok = std::make_unique<Token[]>(1);

EnterTokenStream(std::move(Tok), 1,

,

);

<std::pair<IdentifierInfo *, SourceLocation>>

,

(

I = 0, N =

.size(); I != N; ++I) {

PathString +=

[I].first->getName();

IncludeKind = 0;

tok::pp_include:

tok::pp_import:

tok::pp_include_next:

tok::pp___include_macros:

llvm_unreachable(

);

PP.

(HashLoc, diag::remark_pp_include_directive_modular_translation)

<< IncludeKind << PathString;

StringRef RealPathName,

llvm::sys::path::Style Separator) {

RealPathComponentIter = llvm::sys::path::rbegin(RealPathName);

RealPathComponentEnd = llvm::sys::path::rend(RealPathName);

SuggestReplacement =

;

IsSep = [Separator](StringRef Component) {

Component.size() == 1 &&

llvm::sys::path::is_separator(Component[0], Separator);

(

&Component : llvm::reverse(Components)) {

(

== Component) {

}

(

== Component) {

}

(RealPathComponentIter != RealPathComponentEnd) {

(!IsSep(Component) && !IsSep(*RealPathComponentIter) &&

Component != *RealPathComponentIter) {

SuggestReplacement =

RealPathComponentIter->equals_insensitive(Component);

(!SuggestReplacement)

Component = *RealPathComponentIter;

++RealPathComponentIter;

SuggestReplacement;

*ShadowingModule =

;

}

(ShadowingModule) {

diag::note_previous_definition);

std::pair<ConstSearchDirIterator, const FileEntry *>

Preprocessor::getIncludeNextStart(

&IncludeNextTok)

{

*LookupFromFile =

;

(IncludeNextTok, diag::pp_include_next_in_primary);

}

(CurLexerSubmodule) {

assert(CurPPLexer &&

);

LookupFromFile = *FE;

}

(!Lookup) {

(IncludeNextTok, diag::pp_include_next_absolute_path);

{Lookup, LookupFromFile};

Preprocessor::HandleIncludeDirective(

HashLoc,

(FilenameTok.

(tok::header_name)) {

(FilenameTok.

(tok::eod))

Action = HandleHeaderIncludeOrImport(HashLoc, IncludeTok, FilenameTok,

EndLoc, LookupFrom, LookupFromFile);

(Action.Kind) {

ImportAction::None:

ImportAction::SkippedModuleImport:

ImportAction::ModuleBegin:

tok::annot_module_begin, Action.ModuleForHeader);

ImportAction::HeaderUnitImport:

Action.ModuleForHeader);

ImportAction::ModuleImport:

tok::annot_module_include, Action.ModuleForHeader);

ImportAction::Failure:

);

IncludeTok.

(tok::eof);

CurLexer->cutOffLexing();

&FilenameTok,

&IsFrameworkFound,

IsImportDecl,

*LookupFromFile, StringRef &LookupFilename,

(LangOpts.AsmPreprocessor)

FilenameLoc, LangOpts.ModulesValidateTextualHeaderIncludes);

RequestingModuleIsModuleInterface =

RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc,

FilenameLoc, LookupFilename, isAngled, LookupFrom, LookupFromFile, CurDir,

Callbacks ? &SearchPath :

, Callbacks ? &RelativePath :

,

&SuggestedModule, &IsMapped, &IsFrameworkFound);

DiagnoseHeaderInclusion(*

);

(Callbacks && Callbacks->FileNotFound(

))

std::nullopt;

(SuppressIncludeNotFoundError)

std::nullopt;

FilenameLoc, LookupFilename,

, LookupFrom, LookupFromFile, CurDir,

Callbacks ? &SearchPath :

, Callbacks ? &RelativePath :

,

&SuggestedModule, &IsMapped,

DiagnoseHeaderInclusion(*

);

(FilenameTok, diag::err_pp_file_not_found_angled_include_not_fatal)

StringRef OriginalFilename =

;

(LangOpts.SpellChecking) {

CorrectTypoFilename = [](llvm::StringRef

) {

StringRef TypoCorrectionName = CorrectTypoFilename(

);

StringRef TypoCorrectionLookupName = CorrectTypoFilename(LookupFilename);

FilenameLoc, TypoCorrectionLookupName, isAngled, LookupFrom,

LookupFromFile, CurDir, Callbacks ? &SearchPath :

,

Callbacks ? &RelativePath :

, &SuggestedModule, &IsMapped,

DiagnoseHeaderInclusion(*

);

FilenameRange,

+ TypoCorrectionName.str() +

)

FilenameRange,

+ TypoCorrectionName.str() +

);

(FilenameTok, diag::err_pp_file_not_found_typo_not_fatal)

<< OriginalFilename << TypoCorrectionName << Hint;

LookupFilename = TypoCorrectionLookupName;

assert(!

&&

);

(FilenameTok, diag::err_pp_file_not_found)

<< OriginalFilename << FilenameRange;

(IsFrameworkFound) {

SlashPos = OriginalFilename.find(

);

assert(SlashPos != StringRef::npos &&

);

StringRef FrameworkName = OriginalFilename.substr(0, SlashPos);

assert(CacheEntry.

&&

);

(FilenameTok, diag::note_pp_framework_without_header)

<< OriginalFilename.substr(SlashPos + 1) << FrameworkName

std::nullopt;

Preprocessor::ImportAction Preprocessor::HandleHeaderIncludeOrImport(

StringRef OriginalFilename =

;

{ImportAction::None};

IsImportDecl = HashLoc.

();

(PragmaARCCFCodeAuditedInfo.second.isValid()) {

(StartLoc, diag::err_pp_include_in_arc_cf_code_audited) << IsImportDecl;

(PragmaARCCFCodeAuditedInfo.second, diag::note_pragma_entered_here);

(PragmaAssumeNonNullLoc.

()) {

(StartLoc, diag::err_pp_include_in_assume_nonnull) << IsImportDecl;

(PragmaAssumeNonNullLoc, diag::note_pragma_entered_here);

(!NewName.empty())

IsMapped =

;

IsFrameworkFound =

;

StringRef LookupFilename =

;

llvm::sys::path::Style BackslashStyle = llvm::sys::path::Style::native;

(is_style_posix(BackslashStyle) && LangOpts.MicrosoftExt) {

llvm::sys::path::native(NormalizedPath);

LookupFilename = NormalizedPath;

BackslashStyle = llvm::sys::path::Style::windows;

&CurDir,

, FilenameLoc, FilenameRange, FilenameTok,

IsFrameworkFound, IsImportDecl, IsMapped, LookupFrom, LookupFromFile,

LookupFilename, RelativePath, SearchPath, SuggestedModule, isAngled);

SkippingUntilPCHThroughHeader =

;

{ImportAction::None};

{ Enter,

,

, IncludeLimitReached } Action = Enter;

(PPOpts->SingleFileParseMode)

Action = IncludeLimitReached;

(Action == Enter && HasReachedMaxIncludeDepth &&

&&

Action = IncludeLimitReached;

MaybeTranslateInclude = Action == Enter &&

&& ModuleToImport &&

UsableHeaderUnit =

;

(

().CPlusPlusModules && ModuleToImport &&

(TrackGMFState.inGMF() || IsImportDecl)

UsableHeaderUnit =

;

(!IsImportDecl) {

ModuleToImport =

;

UsableClangHeaderModule =

(MaybeTranslateInclude && (UsableHeaderUnit || UsableClangHeaderModule)) {

diag::note_implicit_top_level_module_import_here)

{ImportAction::None};

(

*Mod = ModuleToImport; Mod; Mod = Mod->

)

std::reverse(

.begin(),

.end());

assert((Imported ==

|| Imported == ModuleToImport) &&

);

*

(Imported)->getTopLevelModule());

ModuleToImport =

;

assert(CurLexer &&

);

CurLexer->FormTokenWithChars(

, CurLexer->BufferEnd, tok::eof);

CurLexer->cutOffLexing();

{ImportAction::None};

IsFirstIncludeOfFile =

;

(Action == Enter &&

&&

IsFirstIncludeOfFile)) {

(UsableHeaderUnit && !

().CompilingPCH)

Action = TrackGMFState.inGMF() ?

:

;

Action = (ModuleToImport && !

().CompilingPCH) ? Import :

;

(Action == Enter &&

&& PreambleConditionalStack.isRecording() &&

diag::err_pp_including_mainfile_in_preamble);

{ImportAction::None};

(Callbacks && !IsImportDecl) {

Callbacks->InclusionDirective(HashLoc, IncludeTok, LookupFilename, isAngled,

FilenameRange,

, SearchPath, RelativePath,

SuggestedModule.

(), Action == Import,

Callbacks->FileSkipped(*

, FilenameTok, FileCharacter);

{ImportAction::None};

(IsImportDecl && !ModuleToImport) {

(FilenameTok, diag::err_header_import_not_header_unit)

<< OriginalFilename <<

->getName();

{ImportAction::None};

CheckIncludePathPortability =

!IsMapped && !

->getFileEntry().tryGetRealPathName().empty();

(CheckIncludePathPortability) {

StringRef Name = LookupFilename;

StringRef NameWithoriginalSlashes =

;

NameWasUNC = Name.consume_front(

);

NameWithoriginalSlashes.consume_front(

);

StringRef RealPathName =

->getFileEntry().tryGetRealPathName();

llvm::sys::path::end(Name));

(llvm::sys::path::is_absolute(Name) &&

llvm::sys::path::is_absolute(RealPathName) &&

assert(Components.size() >= 3 &&

);

assert(Components[0].size() == 2 &&

);

assert(Components[0][1] ==

&&

);

FixedDriveRealPath = (Name.substr(0, 1) + RealPathName.substr(1)).str();

RealPathName = FixedDriveRealPath;

.reserve(Name.size()+2);

.push_back(isAngled ?

:

);

IsSep = [BackslashStyle](

) {

llvm::sys::path::is_separator(

, BackslashStyle);

(

Component : Components) {

(!(Component.size() == 1 && IsSep(Component[0])))

.append(Component);

(

.size() != 1)

(

.size() > NameWithoriginalSlashes.size()) {

.push_back(isAngled ?

:

);

assert(IsSep(NameWithoriginalSlashes[

.size()-1]));

.push_back(NameWithoriginalSlashes[

.size()-1]);

(

.size() <= NameWithoriginalSlashes.size() &&

IsSep(NameWithoriginalSlashes[

.size()-1]));

= (

.substr(0, 1) +

+

.substr(1)).str();

? diag::pp_nonportable_path

: diag::pp_nonportable_system_path;

(FilenameTok, DiagId) <<

<<

{ImportAction::SkippedModuleImport, ModuleToImport};

{ImportAction::None};

IncludeLimitReached:

{ImportAction::None};

assert(ModuleToImport &&

);

tok::pp___include_macros)

{ImportAction::None};

{ImportAction::ModuleImport, ModuleToImport};

(IncludeMacroStack.size() == MaxAllowedIncludeStackDepth-1) {

(FilenameTok, diag::err_pp_include_too_deep);

HasReachedMaxIncludeDepth =

;

{ImportAction::None};

(FilenameTok, diag::warn_pp_include_angled_in_module_purview)

ImportAction::Failure;

IsFirstIncludeOfFile))

{ImportAction::None};

(ModuleToImport && !ModuleToImport->

()) {

diag::err_module_build_shadowed_submodule)

diag::note_previous_definition);

{ImportAction::None};

{ImportAction::None};

assert(!CurLexerSubmodule &&

);

CurLexerSubmodule = ModuleToImport;

{ImportAction::ModuleBegin, ModuleToImport};

assert(!IsImportDecl &&

);

{ImportAction::None};

Preprocessor::HandleIncludeNextDirective(

HashLoc,

&IncludeNextTok) {

(IncludeNextTok, diag::ext_pp_include_next_directive);

std::tie(Lookup, LookupFromFile) = getIncludeNextStart(IncludeNextTok);

HandleIncludeDirective(HashLoc, IncludeNextTok, Lookup,

Preprocessor::HandleMicrosoftImportDirective(

&Tok) {

(Tok, diag::err_pp_import_directive_ms );

(!LangOpts.ObjC) {

(LangOpts.MSVCCompat)

HandleMicrosoftImportDirective(ImportTok);

(ImportTok, diag::ext_pp_import_directive);

HandleIncludeDirective(HashLoc, ImportTok);

Preprocessor::HandleIncludeMacrosDirective(

HashLoc,

&IncludeMacrosTok) {

diag::pp_include_macros_out_of_predefines);

HandleIncludeDirective(HashLoc, IncludeMacrosTok);

assert(TmpTok.

(tok::eof) &&

);

}

(TmpTok.

(tok::hashhash));

Preprocessor::ReadMacroParameterList(

*MI,

&Tok) {

(Tok, diag::err_pp_expected_ident_in_arg_list);

(Tok, LangOpts.CPlusPlus11 ?

diag::warn_cxx98_compat_variadic_macro :

diag::ext_variadic_macro);

(LangOpts.OpenCL && !LangOpts.OpenCLCPlusPlus) {

(Tok, diag::ext_pp_opencl_variadic_macros);

(Tok.

(tok::r_paren)) {

(Tok, diag::err_pp_missing_rparen_in_macro_def);

(Tok, diag::err_pp_missing_rparen_in_macro_def);

(Tok, diag::err_pp_invalid_tok_in_arg_list);

(llvm::is_contained(Parameters, II)) {

(Tok, diag::err_pp_duplicate_name_in_arg_list) << II;

(Tok, diag::err_pp_expected_comma_in_arg_list);

(Tok, diag::ext_named_variadic_macro);

(Tok.

(tok::r_paren)) {

(Tok, diag::err_pp_missing_rparen_in_macro_def);

StringRef ValueText = II->

();

StringRef TrimmedValue = ValueText;

(!ValueText.starts_with(

)) {

(ValueText.starts_with(

))

TrimmedValue = TrimmedValue.drop_front(1);

TrimmedValue = TrimmedValue.drop_front(2);

(TrimmedValue.ends_with(

))

TrimmedValue = TrimmedValue.drop_back(2);

TrimmedValue == MacroText;

MacroName.

(tok::kw_extern, tok::kw_inline, tok::kw_static,

*Preprocessor::ReadOptionalMacroParameterListAndBody(

&MacroNameTok,

ImmediatelyAfterHeaderGuard) {

LastTok = MacroNameTok;

_ = llvm::make_scope_exit([&]() {

(CurLexer->ParsingPreprocessorDirective)

(Tok.

(tok::eod)) {

(ImmediatelyAfterHeaderGuard) {

}

(Tok.

(tok::l_paren)) {

(ReadMacroParameterList(MI, LastTok))

}

(LangOpts.C99 || LangOpts.CPlusPlus11) {

(Tok, diag::ext_c99_whitespace_required_after_macro_name);

(Tok.

(tok::at))

(Tok.

(tok::unknown)) {

(Tok, diag::ext_missing_whitespace_after_macro_name);

(Tok, diag::warn_missing_whitespace_after_macro_name);

(!Tok.

(tok::eod))

(Tok.

(tok::eod)) {

Tokens.push_back(Tok);

(Tok.

(tok::eod)) {

(!Tok.

(tok::hash, tok::hashat, tok::hashhash)) {

Tokens.push_back(Tok);

(VAOCtx.isVAOptToken(Tok)) {

(VAOCtx.isInVAOpt()) {

(Tok, diag::err_pp_vaopt_nested_use);

(Tok.

(tok::l_paren)) {

(Tok, diag::err_pp_missing_lparen_in_vaopt_use);

Tokens.push_back(Tok);

VAOCtx.sawVAOptFollowedByOpeningParens(Tok.

());

(Tok.

(tok::hashhash)) {

(Tok, diag::err_vaopt_paste_at_start);

}

(VAOCtx.isInVAOpt()) {

(Tok.

(tok::r_paren)) {

(VAOCtx.sawClosingParen()) {

assert(Tokens.size() >= 3 &&

);

(Tokens[Tokens.size() - 2].is(tok::hashhash)) {

(Tok, diag::err_vaopt_paste_at_end);

}

(Tok.

(tok::l_paren)) {

Tokens.push_back(Tok);

(Tok.

(tok::hashhash)) {

(Tok.

(tok::eod)) {

Tokens.push_back(LastTok);

Tokens[Tokens.size() - 1].is(tok::comma))

Tokens.push_back(LastTok);

(!VAOCtx.isVAOptToken(Tok) &&

LastTok.

(tok::unknown);

Tokens.push_back(LastTok);

(Tok, diag::err_pp_stringize_not_parameter)

<< LastTok.

(tok::hashat);

Tokens.push_back(LastTok);

(!VAOCtx.isVAOptToken(Tok)) {

Tokens.push_back(Tok);

(VAOCtx.isInVAOpt()) {

assert(Tok.

(tok::eod) &&

);

(Tok, diag::err_pp_expected_after)

<< LastTok.

() << tok::r_paren;

(VAOCtx.getUnmatchedOpeningParenLoc(), diag::note_matching) << tok::l_paren;

II->

(

) || II->

(

) ||

II->

(

) || II->

(

);

Preprocessor::HandleDefineDirective(

&DefineTok,

ImmediatelyAfterHeaderGuard) {

MacroShadowsKeyword;

ReadMacroName(MacroNameTok,

, &MacroShadowsKeyword);

(MacroNameTok.

(tok::eod))

emitFinalMacroWarning(MacroNameTok,

);

(CurLexer) CurLexer->SetCommentRetentionState(KeepMacroComments);

*

MI = ReadOptionalMacroParameterListAndBody(

MacroNameTok, ImmediatelyAfterHeaderGuard);

(MacroShadowsKeyword &&

(MacroNameTok, diag::warn_pp_macro_hides_keyword);

(NumTokens != 0) {

(SkippingUntilPCHThroughHeader) {

LangOpts.MicrosoftExt))

(!LangOpts.MicrosoftExt)

emitFinalMacroWarning(MacroNameTok,

);

LangOpts.MicrosoftExt)) {

(MacroNameTok, diag::ext_pp_redef_builtin_macro);

!MI->

(*OtherMI, *

,

LangOpts.MicrosoftExt)) {

!MacroExpansionInDirectivesOverride &&

Callbacks->MacroDefined(MacroNameTok, MD);

Tok.

(tok::kw__Static_assert);

Preprocessor::HandleUndefDirective() {

ReadMacroName(MacroNameTok,

);

(MacroNameTok.

(tok::eod))

emitFinalMacroWarning(MacroNameTok,

);

(MacroNameTok, diag::ext_pp_undef_builtin_macro);

Undef = AllocateUndefMacroDirective(MacroNameTok.

());

Callbacks->MacroUndefined(MacroNameTok, MD, Undef);

Preprocessor::HandleIfdefDirective(

&

,

&HashToken,

ReadAnyTokensBeforeDirective) {

ReadMacroName(MacroNameTok);

(MacroNameTok.

(tok::eod)) {

SkipExcludedConditionalBlock(HashToken.

(),

(!ReadAnyTokensBeforeDirective && !MI) {

assert(isIfndef &&

);

Callbacks->Ifndef(DirectiveTok.

(), MacroNameTok, MD);

Callbacks->Ifdef(DirectiveTok.

(), MacroNameTok, MD);

RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&

(PPOpts->SingleFileParseMode && !MI) {

}

(!MI == isIfndef || RetainExcludedCB) {

SkipExcludedConditionalBlock(HashToken.

(),

Preprocessor::HandleIfDirective(

&IfToken,

&HashToken,

ReadAnyTokensBeforeDirective) {

DirectiveEvalResult DER = EvaluateDirectiveExpression(IfNDefMacro);

ConditionalTrue = DER.Conditional;

(!ReadAnyTokensBeforeDirective && IfNDefMacro && ConditionalTrue)

RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&

(PPOpts->SingleFileParseMode && DER.IncludedUndefinedIds) {

}

(ConditionalTrue || RetainExcludedCB) {

Preprocessor::HandleEndifDirective(

&EndifToken) {

(EndifToken, diag::err_pp_endif_without_if);

);

Preprocessor::HandleElseDirective(

&

,

&HashToken) {

(

, diag::pp_err_else_without_if);

Callbacks->Else(

.getLocation(), CI.

);

RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&

((PPOpts->SingleFileParseMode && !CI.

) || RetainExcludedCB) {

,

.getLocation());

Preprocessor::HandleElifFamilyDirective(

&ElifToken,

&HashToken,

(LangOpts.CPlusPlus)

DiagID = LangOpts.CPlusPlus23 ? diag::warn_cxx23_compat_pp_directive

: diag::ext_cxx23_pp_directive;

DiagID = LangOpts.C23 ? diag::warn_c23_compat_pp_directive

: diag::ext_c23_pp_directive;

(ElifToken, DiagID) << DirKind;

(ElifToken, diag::pp_err_elif_without_if) << DirKind;

(ElifToken, diag::pp_err_elif_after_else) << DirKind;

Callbacks->Elif(ElifToken.

(), ConditionRange,

tok::pp_elifdef:

tok::pp_elifndef:

Callbacks->Elifndef(ElifToken.

(), ConditionRange, CI.

);

assert(

&&

);

RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&

((PPOpts->SingleFileParseMode && !CI.

) || RetainExcludedCB) {

SkipExcludedConditionalBlock(

std::optional<LexEmbedParametersResult>

EndTokenKind = ForHasEmbed ? tok::r_paren : tok::eod;

DiagMismatchedBracesAndSkipToEOD =

std::pair<tok::TokenKind, SourceLocation> Matches) {

(Matches.second, diag::note_matching) << Matches.first;

(CurTok.

(tok::eod))

(CurTok.

(Kind)) {

(CurTok, diag::err_expected) << Kind;

(CurTok.

(tok::eod))

LexPPParameterName = [&]() -> std::optional<std::string> {

(!ExpectOrDiagAndSkipToEOD(tok::identifier))

std::nullopt;

(CurTok.

(tok::coloncolon)) {

(!ExpectOrDiagAndSkipToEOD(tok::identifier))

std::nullopt;

(llvm::Twine(Prefix->

()) +

+ Suffix->

()).str();

Prefix->

().str();

NormalizeParameterName = [](StringRef Name) {

(Name.size() > 4 && Name.starts_with(

) && Name.ends_with(

))

Name.substr(2, Name.size() - 4);

LexParenthesizedIntegerExpr = [&]() -> std::optional<size_t> {

(!ExpectOrDiagAndSkipToEOD(tok::l_paren))

std::nullopt;

EvaluatedDefined;

DirectiveEvalResult LimitEvalResult = EvaluateDirectiveExpression(

ParameterIfNDef, CurTok, EvaluatedDefined,

);

(!LimitEvalResult.Value) {

assert(CurTok.

(tok::eod) &&

);

std::nullopt;

(!ExpectOrDiagAndSkipToEOD(tok::r_paren))

std::nullopt;

(EvaluatedDefined) {

(CurTok, diag::err_defined_in_pp_embed);

std::nullopt;

(LimitEvalResult.Value) {

llvm::APSInt &

= *LimitEvalResult.Value;

(

.isNegative()) {

(CurTok, diag::err_requires_positive_value)

std::nullopt;

.getLimitedValue();

std::nullopt;

tok::r_paren;

tok::r_brace;

tok::r_square;

llvm_unreachable(

);

LexParenthesizedBalancedTokenSoup =

std::vector<std::pair<tok::TokenKind, SourceLocation>> BracketStack;

(!ExpectOrDiagAndSkipToEOD(tok::l_paren))

WaitingForInnerCloseParen =

;

(CurTok.

(tok::eod) &&

(WaitingForInnerCloseParen || CurTok.

(tok::r_paren))) {

WaitingForInnerCloseParen =

;

WaitingForInnerCloseParen =

;

tok::r_square: {

GetMatchingCloseBracket(BracketStack.back().first);

(BracketStack.empty() || CurTok.

() != Matching) {

DiagMismatchedBracesAndSkipToEOD(Matching, BracketStack.back());

BracketStack.pop_back();

Tokens.push_back(CurTok);

(!ExpectOrDiagAndSkipToEOD(tok::r_paren))

(!CurTok.

(EndTokenKind, tok::eod)) {

std::optional<std::string> ParamName = LexPPParameterName();

std::nullopt;

StringRef

= NormalizeParameterName(*ParamName);

(

.MaybeLimitParam)

std::optional<size_t> Limit = LexParenthesizedIntegerExpr();

std::nullopt;

.MaybeLimitParam =

}

(

==

) {

(

.MaybeOffsetParam)

std::optional<size_t> Offset = LexParenthesizedIntegerExpr();

std::nullopt;

*Offset, {ParamStartLoc, CurTok.

()}};

(

.MaybePrefixParam)

(!LexParenthesizedBalancedTokenSoup(Soup))

std::nullopt;

std::move(Soup), {ParamStartLoc, CurTok.

()}};

(

.MaybeSuffixParam)

(!LexParenthesizedBalancedTokenSoup(Soup))

std::nullopt;

std::move(Soup), {ParamStartLoc, CurTok.

()}};

(

.MaybeIfEmptyParam)

(!LexParenthesizedBalancedTokenSoup(Soup))

std::nullopt;

std::move(Soup), {ParamStartLoc, CurTok.

()}};

++

.UnrecognizedParams;

(CurTok.

(tok::l_paren)) {

(!LexParenthesizedBalancedTokenSoup(Soup))

std::nullopt;

(CurTok, diag::err_pp_unknown_parameter) << 1 <<

;

std::nullopt;

Preprocessor::HandleEmbedDirectiveImpl(

StringRef BinaryContents) {

(BinaryContents.empty()) {

TokCount = Toks.size();

NewToks = std::make_unique<Token[]>(TokCount);

llvm::copy(Toks, NewToks.get());

EnterTokenStream(std::move(NewToks), TokCount,

,

);

TotalNumToks = 1 + NumPrefixToks + NumSuffixToks;

Toks = std::make_unique<Token[]>(TotalNumToks);

CurIdx += NumPrefixToks;

->BinaryData = BinaryContents;

Toks[CurIdx].startToken();

Toks[CurIdx].setKind(tok::annot_embed);

Toks[CurIdx].setAnnotationRange(HashLoc);

Toks[CurIdx++].setAnnotationValue(

);

CurIdx += NumSuffixToks;

assert(CurIdx == TotalNumToks &&

);

EnterTokenStream(std::move(Toks), TotalNumToks,

,

);

(EmbedTok, diag::warn_compat_pp_embed_directive);

(EmbedTok, diag::ext_pp_embed_directive)

<< (LangOpts.CPlusPlus ?

1 :

0);

(FilenameTok.

(tok::header_name)) {

(FilenameTok.

(tok::eod))

std::optional<LexEmbedParametersResult> Params =

assert((Params || CurTok.

(tok::eod)) &&

);

StringRef OriginalFilename =

;

(!MaybeFileRef) {

(Callbacks && Callbacks->EmbedFileNotFound(OriginalFilename)) {

(FilenameTok, diag::err_pp_file_not_found) <<

;

std::optional<llvm::MemoryBufferRef> MaybeFile =

(FilenameTok, diag::err_cannot_open_file)

<<

<<

;

StringRef BinaryContents = MaybeFile->getBuffer();

(Params->MaybeOffsetParam) {

BinaryContents = BinaryContents.substr(Params->MaybeOffsetParam->Offset);

(Params->MaybeLimitParam) {

BinaryContents = BinaryContents.substr(0, Params->MaybeLimitParam->Limit);

Callbacks->EmbedDirective(HashLoc,

, isAngled, MaybeFileRef,

HandleEmbedDirectiveImpl(HashLoc, *Params, BinaryContents);

static bool isInMainFile(const clang::Diagnostic &D)

Defines interfaces for clang::DirectoryEntry and clang::DirectoryEntryRef.

Defines the clang::FileManager interface and associated types.

Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.

Defines the clang::LangOptions interface.

Defines the clang::MacroInfo and clang::MacroDirective classes.

Defines the clang::Module class, which describes a module in the source code.

Defines the PPCallbacks interface.

static bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit, SrcMgr::CharacteristicKind &FileKind, Preprocessor &PP)

ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line marker directive.

static bool isConfigurationPattern(Token &MacroName, MacroInfo *MI, const LangOptions &LOptions)

static std::optional< StringRef > findSimilarStr(StringRef LHS, const std::vector< StringRef > &Candidates)

Find a similar string in Candidates.

static bool isLanguageDefinedBuiltin(const SourceManager &SourceMgr, const MacroInfo *MI, const StringRef MacroName)

static bool trySimplifyPath(SmallVectorImpl< StringRef > &Components, StringRef RealPathName, llvm::sys::path::Style Separator)

static void diagnoseAutoModuleImport(Preprocessor &PP, SourceLocation HashLoc, Token &IncludeTok, ArrayRef< std::pair< IdentifierInfo *, SourceLocation > > Path, SourceLocation PathEnd)

Produce a diagnostic informing the user that a #include or similar was implicitly treated as a module...

static bool warnByDefaultOnWrongCase(StringRef Include)

MacroDiag

Enumerates possible cases of #define/#undef a reserved identifier.

@ MD_ReservedAttributeIdentifier

static bool isFeatureTestMacro(StringRef MacroName)

static bool GetLineValue(Token &DigitTok, unsigned &Val, unsigned DiagID, Preprocessor &PP, bool IsGNULineDirective=false)

GetLineValue - Convert a numeric token into an unsigned value, emitting Diagnostic DiagID if it is in...

PPElifDiag

Enumerates possible select values for the pp_err_elif_after_else and pp_err_elif_without_if diagnosti...

static bool isReservedCXXAttributeName(Preprocessor &PP, IdentifierInfo *II)

static MacroDiag shouldWarnOnMacroUndef(Preprocessor &PP, IdentifierInfo *II)

static bool isObjCProtectedMacro(const IdentifierInfo *II)

static MacroDiag shouldWarnOnMacroDef(Preprocessor &PP, IdentifierInfo *II)

Defines the clang::Preprocessor interface.

static std::string toString(const clang::SanitizerSet &Sanitizers)

Produce a string containing comma-separated names of sanitizers in Sanitizers set.

Defines the clang::SourceLocation class and associated facilities.

static bool isInvalid(LocType Loc, bool *Invalid)

Defines the SourceManager interface.

Defines the clang::TokenKind enum and support functions.

__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)

__device__ __2f16 float c

ResetMacroExpansionHelper(Preprocessor *pp)

~ResetMacroExpansionHelper()

static AttrArgsInfo getCXX11AttrArgsInfo(const IdentifierInfo *Name)

Represents a character-granular source range.

static CharSourceRange getCharRange(SourceRange R)

SourceLocation getEnd() const

virtual void CodeCompleteMacroName(bool IsDefinition)

Callback invoked when performing code completion in a context where the name of a macro is expected.

virtual void CodeCompleteInConditionalExclusion()

Callback invoked when performing code completion within a block of code that was excluded due to prep...

virtual void CodeCompleteDirective(bool InConditional)

Callback invoked when performing code completion for a preprocessor directive.

A directive for a defined macro or a macro imported from a module.

Concrete class used by the front-end to report problems and issues.

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

bool isIgnored(unsigned DiagID, SourceLocation Loc) const

Determine whether the diagnostic is known to be ignored.

A reference to a DirectoryEntry that includes the name of the directory as it was accessed by the Fil...

StringRef getName() const

A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...

const FileEntry & getFileEntry() const

DirectoryEntryRef getDir() const

Cached information about one file (either on disk or in the virtual file system).

StringRef tryGetRealPathName() const

An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...

Implements support for file system lookup, file system caching, and directory search management.

llvm::Expected< DirectoryEntryRef > getDirectoryRef(StringRef DirName, bool CacheFailure=true)

Lookup, cache, and verify the specified directory (real or virtual).

OptionalDirectoryEntryRef getOptionalDirectoryRef(StringRef DirName, bool CacheFailure=true)

Get a DirectoryEntryRef if it exists, without doing anything on error.

LLVM_DEPRECATED("Functions returning DirectoryEntry are deprecated.", "getOptionalDirectoryRef()") llvm LLVM_DEPRECATED("Functions returning FileEntry are deprecated.", "getOptionalFileRef()") llvm llvm::Expected< FileEntryRef > getFileRef(StringRef Filename, bool OpenFile=false, bool CacheFailure=true, bool IsText=true)

Lookup, cache, and verify the specified directory (real or virtual).

Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...

static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)

Create a code modification hint that replaces the given source range with the given code string.

static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)

Create a code modification hint that inserts the given code string at a specific location.

One of these records is kept for each identifier that is lexed.

tok::PPKeywordKind getPPKeywordID() const

Return the preprocessor keyword ID for this identifier.

bool isCPlusPlusOperatorKeyword() const

bool hadMacroDefinition() const

Returns true if this identifier was #defined to some value at any moment.

bool hasMacroDefinition() const

Return true if this identifier is #defined to some other value.

const char * getNameStart() const

Return the beginning of the actual null-terminated string for this identifier.

bool isKeyword(const LangOptions &LangOpts) const

Return true if this token is a keyword in the specified language.

ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const

Determine whether this is a name reserved for the implementation (C99 7.1.3, C++ [lib....

bool isStr(const char(&Str)[StrLen]) const

Return true if this is the identifier for the specified string.

StringRef getName() const

Return the actual identifier string.

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

bool IsHeaderFile

Indicates whether the front-end is explicitly told that the input is a header file (i....

std::string CurrentModule

The name of the current module, of which the main source file is a part.

Encapsulates changes to the "macros namespace" (the location where the macro name became active,...

const MacroInfo * getMacroInfo() const

Encapsulates the data about a macro definition (e.g.

bool isIdenticalTo(const MacroInfo &Other, Preprocessor &PP, bool Syntactically) const

Return true if the specified macro definition is equal to this macro in spelling, arguments,...

bool isUsed() const

Return false if this macro is defined in the main file and has not yet been used.

bool isC99Varargs() const

bool isAllowRedefinitionsWithoutWarning() const

Return true if this macro can be redefined without warning.

void setHasCommaPasting()

unsigned getNumTokens() const

Return the number of tokens that this macro expands to.

const Token & getReplacementToken(unsigned Tok) const

void setDefinitionEndLoc(SourceLocation EndLoc)

Set the location of the last token in the macro.

bool isBuiltinMacro() const

Return true if this macro requires processing before expansion.

void setTokens(ArrayRef< Token > Tokens, llvm::BumpPtrAllocator &PPAllocator)

void setParameterList(ArrayRef< IdentifierInfo * > List, llvm::BumpPtrAllocator &PPAllocator)

Set the specified list of identifiers as the parameter list for this macro.

SourceLocation getDefinitionLoc() const

Return the location that the macro was defined at.

void setIsFunctionLike()

Function/Object-likeness.

bool isObjectLike() const

void setIsWarnIfUnused(bool val)

Set the value of the IsWarnIfUnused flag.

int getParameterNum(const IdentifierInfo *Arg) const

Return the parameter number of the specified identifier, or -1 if the identifier is not a formal para...

bool isWarnIfUnused() const

Return true if we should emit a warning if the macro is unused.

void setIsC99Varargs()

Varargs querying methods. This can only be set for function-like macros.

Describes the result of attempting to load a module.

bool isMissingExpected() const

Determines whether the module, which failed to load, was actually a submodule that we expected to see...

bool isConfigMismatch() const

Determines whether the module failed to load due to a configuration mismatch with an explicitly-named...

virtual ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective)=0

Attempt to load the given module.

void diagnoseHeaderInclusion(Module *RequestingModule, bool RequestingModuleIsModuleInterface, SourceLocation FilenameLoc, StringRef Filename, FileEntryRef File)

Reports errors if a module must not include a specific file.

KnownHeader findModuleForHeader(FileEntryRef File, bool AllowTextual=false, bool AllowExcluded=false)

Retrieve the module that owns the given header file, if any.

bool shouldImportRelativeToBuiltinIncludeDir(StringRef FileName, Module *Module) const

OptionalDirectoryEntryRef getBuiltinDir() const

Get the directory that contains Clang-supplied include files.

@ ExcludedHeader

This header is explicitly excluded from the module.

@ TextualHeader

This header is part of the module (for layering purposes) but should be textually included.

Describes a module or submodule.

StringRef getTopLevelModuleName() const

Retrieve the name of the top-level module.

bool isForBuilding(const LangOptions &LangOpts) const

Determine whether this module can be built in this compilation.

@ Hidden

All of the names in this module are hidden.

SourceLocation DefinitionLoc

The location of the module definition.

Module * Parent

The parent of this module.

unsigned IsSystem

Whether this is a "system" module (which assumes that all headers in it are system headers).

std::string Name

The name of this module.

bool isAvailable() const

Determine whether this module is available for use within the current translation unit.

bool isHeaderUnit() const

Is this module a header unit.

Module * ShadowingModule

A module with the same name that shadows this module.

std::string getFullModuleName(bool AllowStringLiterals=false) const

Retrieve the full name of this module, including the path from its top-level module.

Module * getTopLevelModule()

Retrieve the top-level module for this (sub)module, which may be this module.

bool getHasReadAnyTokensVal() const

getHasReadAnyTokensVal - This is used for the #ifndef handshake at the top of the file when reading p...

void ExitTopLevelConditional()

Called when the lexer exits the top-level conditional.

void SetDefinedMacro(IdentifierInfo *M, SourceLocation Loc)

void SetReadToken(bool Value)

SetReadToken - Set whether the value of 'ReadAnyTokens'.

bool getImmediatelyAfterTopLevelIfndef() const

getImmediatelyAfterTopLevelIfndef - returns true if the last directive was an #ifndef at the beginnin...

void EnterTopLevelConditional()

Invoked when a top level conditional (except #ifndef) is found.

void resetImmediatelyAfterTopLevelIfndef()

void EnterTopLevelIfndef(const IdentifierInfo *M, SourceLocation Loc)

Called when entering a top-level #ifndef directive (or the "\#if !defined" equivalent) without any pr...

Preprocessor standard embed parameter "if_empty" if_empty( balanced-token-seq )

Preprocessor standard embed parameter "limit" limit( constant-expression )

Preprocessor extension embed parameter "clang::offset" clang::offset( constant-expression )

Preprocessor standard embed parameter "prefix" prefix( balanced-token-seq )

Preprocessor standard embed parameter "suffix" suffix( balanced-token-seq )

void pushConditionalLevel(SourceLocation DirectiveStart, bool WasSkipping, bool FoundNonSkip, bool FoundElse)

pushConditionalLevel - When we enter a #if directive, this keeps track of what we are currently in fo...

unsigned getConditionalStackDepth() const

bool LexingRawMode

True if in raw mode.

bool ParsingPreprocessorDirective

True when parsing #XXX; turns '\n' into a tok::eod token.

MultipleIncludeOpt MIOpt

A state machine that detects the #ifndef-wrapping a file idiom for the multiple-include optimization.

bool popConditionalLevel(PPConditionalInfo &CI)

popConditionalLevel - Remove an entry off the top of the conditional stack, returning information abo...

OptionalFileEntryRef getFileEntry() const

getFileEntry - Return the FileEntry corresponding to this FileID.

PPConditionalInfo & peekConditionalLevel()

Return the top of the conditional stack.

virtual SourceLocation getSourceLocation()=0

Return the source location for the next observable location.

Engages in a tight little dance with the lexer to efficiently preprocess tokens.

MacroDirective * getLocalMacroDirective(const IdentifierInfo *II) const

Given an identifier, return its latest non-imported MacroDirective if it is #define'd and not #undef'...

void markClangModuleAsAffecting(Module *M)

Mark the given clang module as affecting the current clang module or translation unit.

OptionalFileEntryRef LookupEmbedFile(StringRef Filename, bool isAngled, bool OpenFile, const FileEntry *LookupFromFile=nullptr)

Given a "Filename" or <Filename> reference, look up the indicated embed resource.

const MacroInfo * getMacroInfo(const IdentifierInfo *II) const

bool isRecordingPreamble() const

void HandleSkippedDirectiveWhileUsingPCH(Token &Result, SourceLocation HashLoc)

Process directives while skipping until the through header or #pragma hdrstop is found.

bool isInPrimaryFile() const

Return true if we're in the top-level file, not in a #include.

void markMacroAsUsed(MacroInfo *MI)

A macro is used, update information about macros that need unused warnings.

void EnterSubmodule(Module *M, SourceLocation ImportLoc, bool ForPragma)

void setCodeCompletionReached()

Note that we hit the code-completion point.

StringRef getNamedModuleName() const

Get the named module name we're preprocessing.

void makeModuleVisible(Module *M, SourceLocation Loc)

void Lex(Token &Result)

Lex the next token for this preprocessor.

bool EnterSourceFile(FileID FID, ConstSearchDirIterator Dir, SourceLocation Loc, bool IsFirstIncludeOfFile=true)

Add a source file to the top of the include stack and start lexing tokens from it instead of the curr...

void LexNonComment(Token &Result)

Lex a token.

SourceRange DiscardUntilEndOfDirective()

Read and discard all tokens remaining on the current line until the tok::eod token is found.

SourceLocation CheckEndOfDirective(const char *DirType, bool EnableMacros=false)

Ensure that the next token is a tok::eod token.

IdentifierInfo * getIdentifierInfo(StringRef Name) const

Return information about the specified preprocessor identifier token.

SourceManager & getSourceManager() const

MacroDefinition getMacroDefinition(const IdentifierInfo *II)

bool CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef, bool *ShadowFlag=nullptr)

bool isMacroDefined(StringRef Id)

static bool checkModuleIsAvailable(const LangOptions &LangOpts, const TargetInfo &TargetInfo, const Module &M, DiagnosticsEngine &Diags)

Check that the given module is available, producing a diagnostic if not.

SourceLocation AdvanceToTokenCharacter(SourceLocation TokStart, unsigned Char) const

Given a location that specifies the start of a token, return a new location that specifies a characte...

Module * getCurrentModule()

Retrieves the module that we're currently building, if any.

bool hadModuleLoaderFatalFailure() const

const TargetInfo & getTargetInfo() const

FileManager & getFileManager() const

bool LexHeaderName(Token &Result, bool AllowMacroExpansion=true)

Lex a token, forming a header-name token if possible.

bool isPCHThroughHeader(const FileEntry *FE)

Returns true if the FileEntry is the PCH through header.

friend class VariadicMacroScopeGuard

MacroInfo * AllocateMacroInfo(SourceLocation L)

Allocate a new MacroInfo object with the provided SourceLocation.

void LexUnexpandedToken(Token &Result)

Just like Lex, but disables macro expansion of identifier tokens.

bool alreadyIncluded(FileEntryRef File) const

Return true if this header has already been included.

FileID getPredefinesFileID() const

Returns the FileID for the preprocessor predefines.

void LexUnexpandedNonComment(Token &Result)

Like LexNonComment, but this disables macro expansion of identifier tokens.

StringRef getSpelling(SourceLocation loc, SmallVectorImpl< char > &buffer, bool *invalid=nullptr) const

Return the 'spelling' of the token at the given location; does not go up to the spelling location or ...

bool GetIncludeFilenameSpelling(SourceLocation Loc, StringRef &Buffer)

Turn the specified lexer token into a fully checked and spelled filename, e.g.

PreprocessorLexer * getCurrentFileLexer() const

Return the current file lexer being lexed from.

HeaderSearch & getHeaderSearchInfo() const

void emitMacroExpansionWarnings(const Token &Identifier, bool IsIfnDef=false) const

bool isNextPPTokenLParen()

Determine whether the next preprocessor token to be lexed is a '('.

void HandleDirective(Token &Result)

Callback invoked when the lexer sees a # token at the start of a line.

void EnterAnnotationToken(SourceRange Range, tok::TokenKind Kind, void *AnnotationVal)

Enter an annotation token into the token stream.

OptionalFileEntryRef LookupFile(SourceLocation FilenameLoc, StringRef Filename, bool isAngled, ConstSearchDirIterator FromDir, const FileEntry *FromFile, ConstSearchDirIterator *CurDir, SmallVectorImpl< char > *SearchPath, SmallVectorImpl< char > *RelativePath, ModuleMap::KnownHeader *SuggestedModule, bool *IsMapped, bool *IsFrameworkFound, bool SkipCache=false, bool OpenFile=true, bool CacheFailures=true)

Given a "foo" or <foo> reference, look up the indicated file.

const LangOptions & getLangOpts() const

bool isInNamedModule() const

If we are preprocessing a named module.

OptionalFileEntryRef getHeaderToIncludeForDiagnostics(SourceLocation IncLoc, SourceLocation MLoc)

We want to produce a diagnostic at location IncLoc concerning an unreachable effect at location MLoc ...

DefMacroDirective * appendDefMacroDirective(IdentifierInfo *II, MacroInfo *MI, SourceLocation Loc)

void HandlePragmaHdrstop(Token &Tok)

DiagnosticsEngine & getDiagnostics() const

std::optional< LexEmbedParametersResult > LexEmbedParameters(Token &Current, bool ForHasEmbed)

Lex the parameters for an #embed directive, returns nullopt on error.

Module * getModuleForLocation(SourceLocation Loc, bool AllowTextual)

Find the module that owns the source or header file that Loc points to.

DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const

Forwarding function for diagnostics.

bool usingPCHWithThroughHeader()

True if using a PCH with a through header.

void appendMacroDirective(IdentifierInfo *II, MacroDirective *MD)

Add a directive to the macro directive history for this identifier.

Represents an unpacked "presumed" location which can be presented to the user.

bool isInvalid() const

Return true if this object is invalid or uninitialized.

SourceLocation getIncludeLoc() const

Return the presumed include location of this location.

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

SourceLocation getLocWithOffset(IntTy Offset) const

Return a source location with the specified offset from this SourceLocation.

This class handles loading and caching of source files into memory.

FileID getFileID(SourceLocation SpellingLoc) const

Return the FileID for a SourceLocation.

bool isWrittenInBuiltinFile(SourceLocation Loc) const

Returns whether Loc is located in a <built-in> file.

bool isInMainFile(SourceLocation Loc) const

Returns whether the PresumedLoc for a given SourceLocation is in the main file.

void AddLineNote(SourceLocation Loc, unsigned LineNo, int FilenameID, bool IsFileEntry, bool IsFileExit, SrcMgr::CharacteristicKind FileKind)

Add a line note to the line table for the FileID and offset specified by Loc.

bool isWrittenInCommandLineFile(SourceLocation Loc) const

Returns whether Loc is located in a <command line> file.

OptionalFileEntryRef getFileEntryRefForID(FileID FID) const

Returns the FileEntryRef for the provided FileID.

StringRef getBufferName(SourceLocation Loc, bool *Invalid=nullptr) const

Return the filename or buffer identifier of the buffer the location is in.

FileID createFileID(FileEntryRef SourceFile, SourceLocation IncludePos, SrcMgr::CharacteristicKind FileCharacter, int LoadedID=0, SourceLocation::UIntTy LoadedOffset=0)

Create a new FileID that represents the specified file being #included from the specified IncludePosi...

bool isMainFile(const FileEntry &SourceFile)

Returns true when the given FileEntry corresponds to the main file.

FileID getMainFileID() const

Returns the FileID of the main source file.

CharSourceRange getExpansionRange(SourceLocation Loc) const

Given a SourceLocation object, return the range of tokens covered by the expansion in the ultimate fi...

unsigned getLineTableFilenameID(StringRef Str)

Return the uniqued ID for the specified filename.

bool isInSystemHeader(SourceLocation Loc) const

Returns if a SourceLocation is in a system header.

SrcMgr::CharacteristicKind getFileCharacteristic(SourceLocation Loc) const

Return the file characteristic of the specified source location, indicating whether this is a normal ...

SourceLocation getExpansionLoc(SourceLocation Loc) const

Given a SourceLocation object Loc, return the expansion location referenced by the ID.

std::optional< llvm::MemoryBufferRef > getMemoryBufferForFileOrNone(FileEntryRef File)

Retrieve the memory buffer associated with the given file.

A trivial tuple used to represent a source range.

void setBegin(SourceLocation b)

SourceLocation getEnd() const

SourceLocation getBegin() const

void setEnd(SourceLocation e)

StringLiteralParser - This decodes string escape characters and performs wide string analysis and Tra...

Exposes information about the current target.

Token - This structure provides full information about a lexed token.

IdentifierInfo * getIdentifierInfo() const

SourceLocation getEndLoc() const

void setAnnotationEndLoc(SourceLocation L)

void clearFlag(TokenFlags Flag)

Unset the specified flag.

SourceLocation getLocation() const

Return a source location identifier for the specified offset in the current file.

unsigned getLength() const

void setKind(tok::TokenKind K)

bool is(tok::TokenKind K) const

is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {....

tok::TokenKind getKind() const

bool isAtStartOfLine() const

isAtStartOfLine - Return true if this token is at the start of a line.

bool hasLeadingSpace() const

Return true if this token has whitespace before it.

void setLocation(SourceLocation L)

bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const

bool isNot(tok::TokenKind K) const

void setAnnotationValue(void *val)

bool hasUDSuffix() const

Return true if this token is a string or character literal which has a ud-suffix.

void startToken()

Reset all flags to cleared.

bool needsCleaning() const

Return true if this token has trigraphs or escaped newlines in it.

void setIdentifierInfo(IdentifierInfo *II)

StringRef getRawIdentifier() const

getRawIdentifier - For a raw identifier token (i.e., an identifier lexed in raw mode),...

A directive for an undefined macro.

A class for tracking whether we're inside a VA_OPT during a traversal of the tokens of a variadic mac...

An RAII class that tracks when the Preprocessor starts and stops lexing the definition of a (ISO C/C+...

void enterScope()

Client code should call this function just before the Preprocessor is about to Lex tokens from the de...

Directive - Abstract class representing a parsed verify directive.

A directive for setting the module visibility of a macro.

Defines the clang::TargetInfo interface.

CharacteristicKind

Indicates whether a file or directory holds normal user code, system code, or system code which is im...

uint32_t Literal

Literals are represented as positive integers.

bool Sub(InterpState &S, CodePtr OpPC)

TokenKind

Provides a simple uniform namespace for tokens from all C languages.

PPKeywordKind

Provides a namespace for preprocessor keywords which start with a '#' at the beginning of the line.

The JSON file list parser is used to communicate input to InstallAPI.

bool isReservedInAllContexts(ReservedIdentifierStatus Status)

Determine whether an identifier is reserved in all contexts.

LLVM_READONLY char toLowercase(char c)

Converts the given ASCII character to its lowercase equivalent.

MacroUse

Context in which macro name is used.

LLVM_READONLY bool isAlphanumeric(unsigned char c)

Return true if this character is an ASCII letter or digit: [a-zA-Z0-9].

@ Parameter

The parameter type of a method or function.

@ Result

The result type of a method or function.

LLVM_READONLY bool isDigit(unsigned char c)

Return true if this character is an ASCII digit: [0-9].

LLVM_READONLY bool isLowercase(unsigned char c)

Return true if this character is a lowercase ASCII letter: [a-z].

int hasAttribute(AttributeCommonInfo::Syntax Syntax, const IdentifierInfo *Scope, const IdentifierInfo *Attr, const TargetInfo &Target, const LangOptions &LangOpts)

Return the version number associated with the attribute if we recognize and implement the attribute s...

@ PIK_HashPragma

The pragma was introduced via #pragma.

Helper class to shuttle information about #embed directives from the preprocessor to the parser throu...

This structure is used to record entries in our framework cache.

OptionalDirectoryEntryRef Directory

The directory entry which should be used for the cached framework.

std::optional< PPEmbedParameterIfEmpty > MaybeIfEmptyParam

size_t SuffixTokenCount() const

std::optional< PPEmbedParameterSuffix > MaybeSuffixParam

std::optional< PPEmbedParameterPrefix > MaybePrefixParam

size_t PrefixTokenCount() const

Information about the conditional stack (#if directives) currently active.

bool FoundNonSkip

True if we have emitted tokens already, and now we're in an #else block or something.

SourceLocation IfLoc

Location where the conditional started.

bool WasSkipping

True if this was contained in a skipping directive, e.g., in a "\#if 0" block.

bool FoundElse

True if we've seen a #else in this block.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4