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

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

clang: lib/Lex/Pragma.cpp Source File

;

IgnoreNull)

{

I = Handlers.find(Name);

(I != Handlers.end())

I->getValue().get();

I = Handlers.find(StringRef());

(I != Handlers.end())

I->getValue().get();

assert(!Handlers.count(Handler->

()) &&

);

Handlers[Handler->

()].reset(Handler);

I = Handlers.find(Handler->

());

assert(I != Handlers.end() &&

);

I->getValue().release();

PP.

(Tok, diag::warn_pragma_ignored);

TokenCollector {

Tokens.push_back(Tok);

assert(Collect &&

);

assert(!Tokens.empty() &&

);

Toks = std::make_unique<Token[]>(Tokens.size());

std::copy(Tokens.begin() + 1, Tokens.end(), Toks.get());

Toks[Tokens.size() - 1] = Tok;

Self.EnterTokenStream(std::move(Toks), Tokens.size(),

Tok = *Tokens.begin();

Callbacks->PragmaDirective(Introducer.

, Introducer.

);

PragmaHandlers->HandlePragma(*

, Introducer, Tok);

((CurTokenLexer && CurTokenLexer->isParsingPreprocessorDirective())

Preprocessor::Handle_Pragma(

&Tok) {

TokenCollector Toks = {*

, InMacroArgPreExpansion, {}, Tok};

(Tok.

(tok::l_paren)) {

(PragmaLoc, diag::err__Pragma_malformed);

(PragmaLoc, diag::err__Pragma_malformed);

(Tok.

(tok::r_paren) && Tok.

(tok::eof))

(Tok.

(tok::r_paren) &&

Tok.

(tok::eof))

(Tok.

(tok::r_paren))

(Tok, diag::err_invalid_string_udl);

(Tok.

(tok::r_paren))

(Tok.

(tok::r_paren)) {

(PragmaLoc, diag::err__Pragma_malformed);

(InMacroArgPreExpansion) {

(PragmaLoc, diag::err__Pragma_malformed);

assert(StrValRef.size() <= StrVal.size());

(StrValRef.begin() != StrVal.begin())

StrVal.assign(StrValRef);

(StrValRef.size() != StrVal.size())

StrVal.resize(StrValRef.size());

StrVal.size(), *

);

EnterSourceFileWithLexer(TL,

);

(StrVal[0] ==

|| StrVal[0] ==

||

(StrVal[0] ==

&& StrVal[1] !=

))

StrVal.erase(StrVal.begin());

(StrVal[0] ==

)

StrVal.erase(StrVal.begin(), StrVal.begin() + 2);

(StrVal[0] ==

) {

assert(StrVal[1] ==

&& StrVal[StrVal.size() - 1] ==

&&

);

NumDChars = 0;

(StrVal[2 + NumDChars] !=

) {

assert(NumDChars < (StrVal.size() - 5) / 2 &&

);

assert(StrVal[StrVal.size() - 2 - NumDChars] ==

);

StrVal.erase(StrVal.begin(), StrVal.begin() + 2 + NumDChars);

StrVal.erase(StrVal.end() - 1 - NumDChars, StrVal.end());

assert(StrVal[0] ==

&& StrVal[StrVal.size()-1] ==

&&

);

ResultPos = 1;

(

i = 1, e = StrVal.size() - 1; i != e; ++i) {

(StrVal[i] ==

&& i + 1 < e &&

(StrVal[i + 1] ==

|| StrVal[i + 1] ==

))

StrVal[ResultPos++] = StrVal[i];

StrVal.erase(StrVal.begin() + ResultPos, StrVal.end() - 1);

StrVal[StrVal.size() - 1] =

;

Preprocessor::HandleMicrosoft__pragma(

&Tok) {

TokenCollector Toks = {*

, InMacroArgPreExpansion, {}, Tok};

(Tok.

(tok::l_paren)) {

(PragmaLoc, diag::err__Pragma_malformed);

(Tok.

(tok::eof)) {

PragmaToks.push_back(Tok);

(Tok.

(tok::l_paren))

(Tok.

(tok::r_paren) && NumParens-- == 0)

(Tok.

(tok::eof)) {

(PragmaLoc, diag::err_unterminated___pragma);

(InMacroArgPreExpansion) {

PragmaToks.back().setKind(tok::eod);

*TokArray =

[PragmaToks.size()];

std::copy(PragmaToks.begin(), PragmaToks.end(), TokArray);

EnterTokenStream(TokArray, PragmaToks.size(),

,

,

(OnceTok, diag::pp_pragma_once_in_main_file);

assert(CurPPLexer &&

);

CurLexer->ReadToEndOfLine(&Buffer);

Callbacks->PragmaMark(MarkTok.

(), Buffer);

(Tok.

(tok::eod))

;

(Tok.

(tok::raw_identifier)) {

(Tok, diag::err_pp_invalid_poison);

(Tok, diag::pp_poisoning_existing_macro);

(SysHeaderTok, diag::pp_pragma_sysheader_in_main_file);

Callbacks->FileChanged(SysHeaderTok.

(),

FilenameID,

,

,

(FilenameTok.

(tok::header_name)) {

,

,

,

,

,

,

);

(!SuppressIncludeNotFoundError)

(FilenameTok, diag::err_pp_file_not_found) <<

;

(DependencyTok.

(tok::eod)) {

(!Message.empty())

Message.erase(Message.end()-1);

(FilenameTok, diag::pp_out_of_date_dependency) << Message;

PragmaTok = Tok;

(Tok.

(tok::l_paren)) {

(PragmaTok.

(), diag::err_pragma_push_pop_macro_malformed)

(Tok.

(tok::string_literal)) {

(PragmaTok.

(), diag::err_pragma_push_pop_macro_malformed)

(Tok, diag::err_invalid_string_udl);

(Tok.

(tok::r_paren)) {

(PragmaTok.

(), diag::err_pragma_push_pop_macro_malformed)

assert(StrVal[0] ==

&& StrVal[StrVal.size()-1] ==

&&

);

MacroTok.

(tok::raw_identifier);

(StringRef(&StrVal[1], StrVal.size() - 2), MacroTok);

(!IdentInfo)

;

PragmaPushMacroInfo[IdentInfo].push_back(MI);

(!IdentInfo)

;

llvm::DenseMap<IdentifierInfo *, std::vector<MacroInfo *>>::iterator iter =

PragmaPushMacroInfo.find(IdentInfo);

(iter != PragmaPushMacroInfo.end()) {

(MI->isWarnIfUnused())

WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());

*MacroToReInstall = iter->second.back();

(MacroToReInstall)

iter->second.pop_back();

(iter->second.empty())

PragmaPushMacroInfo.erase(iter);

(MessageLoc, diag::warn_pragma_pop_macro_no_push)

(Tok.

(tok::l_paren)) {

(Tok, diag::warn_pragma_include_alias_expected) <<

;

SourceFilenameTok;

StringRef SourceFileName;

(SourceFilenameTok.

(tok::header_name)) {

SourceFileName =

(SourceFilenameTok, FileNameBuffer);

(Tok, diag::warn_pragma_include_alias_expected_filename);

FileNameBuffer.clear();

(Tok.

(tok::comma)) {

(Tok, diag::warn_pragma_include_alias_expected) <<

;

ReplaceFilenameTok;

StringRef ReplaceFileName;

(ReplaceFilenameTok.

(tok::header_name)) {

ReplaceFileName =

(ReplaceFilenameTok, FileNameBuffer);

(Tok, diag::warn_pragma_include_alias_expected_filename);

(Tok.

(tok::r_paren)) {

(Tok, diag::warn_pragma_include_alias_expected) <<

;

StringRef OriginalSource = SourceFileName;

SourceIsAngled =

ReplaceIsAngled =

(!SourceFileName.empty() && !ReplaceFileName.empty() &&

(SourceIsAngled != ReplaceIsAngled)) {

DiagID = diag::warn_pragma_include_alias_mismatch_angle;

DiagID = diag::warn_pragma_include_alias_mismatch_quote;

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

(Literal.hadError)

ModuleNameComponent = std::make_pair(

ModuleNameComponent =

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

ModuleName.push_back(NameComponent);

(Tok.

(tok::period))

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

(Tok.

(tok::eod)) {

(Tok, diag::ext_pp_extra_tokens_at_eol) <<

;

CurLexer->LexingRawMode =

;

TryConsumeIdentifier = [&](StringRef Ident) ->

{

(Tok.

() != tok::raw_identifier ||

*Start = CurLexer->getBufferLocation();

*End =

;

NestingLevel = 1;

End = CurLexer->getBufferLocation();

(Tok.

(tok::eof)) {

(

, diag::err_pp_module_build_missing_end);

CurLexer->ParsingPreprocessorDirective =

;

(TryConsumeIdentifier(

) && TryConsumeIdentifier(

) &&

TryConsumeIdentifier(

)) {

(TryConsumeIdentifier(

))

(TryConsumeIdentifier(

)) {

(--NestingLevel == 0)

assert(Tok.

() != tok::eof &&

);

CurLexer->LexingRawMode =

;

assert(CurLexer->getBuffer().begin() <= Start &&

Start <= CurLexer->getBuffer().end() &&

CurLexer->getBuffer().begin() <= End &&

End <= CurLexer->getBuffer().end() &&

);

StringRef(Start, End - Start));

(Tok.

(tok::l_paren)) {

(Tok.

(tok::r_paren)) {

(Tok, diag::err_expected) << tok::r_paren;

(Tok.

(tok::eod))

<<

;

assert(CurLexer &&

);

CurLexer->FormTokenWithChars(

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

CurLexer->cutOffLexing();

SkippingUntilPragmaHdrStop =

;

(!Namespace.empty()) {

(

*Existing = PragmaHandlers->FindHandler(Namespace)) {

assert(InsertNS !=

&&

);

PragmaHandlers->AddPragma(InsertNS);

);

(!Namespace.empty()) {

*Existing = PragmaHandlers->FindHandler(Namespace);

assert(Existing &&

);

assert(NS &&

);

(NS != PragmaHandlers.get() && NS->

()) {

PragmaHandlers->RemovePragmaHandler(NS);

(Tok.

(tok::identifier)) {

(Tok, diag::ext_on_off_switch_syntax);

(II->

(

))

(II->

(

))

(II->

(

))

(Tok, diag::ext_on_off_switch_syntax);

(Tok.

(tok::eod))

(Tok, diag::ext_pragma_syntax_eod);

&OnceTok)

{

&MarkTok)

{

&PoisonTok)

{

PragmaSystemHeaderHandler() :

(

) {}

&SHToken)

{

PragmaDependencyHandler() :

(

) {}

&DepToken)

{

&DebugToken)

{

(Tok.

(tok::identifier)) {

PP.

(Tok, diag::warn_pragma_debug_missing_command);

(II->

(

)) {

llvm_unreachable(

);

}

(II->

(

)) {

llvm::Timer

(

,

);

llvm::TimeRegion R(&

);

}

(II->

(

)) {

Crasher.

(tok::annot_pragma_parser_crash);

}

(II->

(

)) {

DumpAnnot.

(tok::annot_pragma_dump);

}

(II->

(

)) {

(DiagName.

(tok::eod))

(DiagName.

(tok::string_literal) && !DiagName.

()) {

StringLiteralEvalMethod::Unevaluated);

PP.

(DiagName, diag::warn_pragma_debug_missing_argument)

}

(II->

(

)) {

llvm::report_fatal_error(

);

}

(II->

(

)) {

llvm_unreachable(

);

}

(II->

(

)) {

PP.

(MacroName, diag::warn_pragma_debug_missing_argument)

}

(II->

(

)) {

(

IIAndLoc : ModuleName) {

PP.

(IIAndLoc.second, diag::warn_pragma_debug_unknown_module)

}

(II->

(

)) {

DebugOverflowStack();

}

(II->

(

)) {

}

(II->

(

)) {

ModuleVisitor {

visit(

*M,

VisibleOnly) {

(!VisibleOnly || ImportLoc.

()) {

llvm::errs() << M <<

;

llvm::errs() <<

;

(!VisibleOnly || ImportLoc.

() ||

->IsExplicit)

visit(Sub, VisibleOnly);

visitAll(

VisibleOnly) {

(

&NameAndMod :

visit(NameAndMod.second, VisibleOnly);

*DumpII =

.getIdentifierInfo();

PP.

(

, diag::warn_pragma_debug_missing_argument)

}

(DumpII->isStr(

)) {

Visitor.visitAll(

);

}

(DumpII->isStr(

)) {

Visitor.visitAll(

);

}

(DumpII->isStr(

)) {

llvm::errs() <<

<< Building.M->getFullModuleName();

(Building.ImportLoc.isValid()) {

llvm::errs() <<

;

(Building.IsPragma)

llvm::errs() <<

;

llvm::errs() <<

;

llvm::errs() <<

;

PP.

(Tok, diag::warn_pragma_debug_unexpected_command)

<< DumpII->getName();

}

(II->

(

)) {

std::optional<unsigned> MaxNotes;

(ArgToken.

(tok::numeric_constant) &&

}

(ArgToken.

(tok::eod)) {

PP.

(ArgToken, diag::warn_pragma_debug_unexpected_argument);

PP.

(Tok, diag::remark_sloc_usage);

PP.

(Tok, diag::warn_pragma_debug_unexpected_command)

(Tok.

(tok::eod)) {

PP.

(Tok, diag::ext_pp_extra_tokens_at_eol)

<<

;

Toks[0].startToken();

Toks[0].setKind(tok::annot_pragma_captured);

Toks[0].setLocation(NameLoc);

PP.EnterTokenStream(Toks,

,

DebugOverflowStack(

(*

)() =

) {

void (*

Self)(void(*

)()) = DebugOverflowStack;

Self(

(*)()

(Self));

PragmaUnsafeBufferUsageHandler :

{

PragmaUnsafeBufferUsageHandler() :

(

) {}

&FirstToken)

{

(Tok.

(tok::identifier)) {

PP.

(Tok, diag::err_pp_pragma_unsafe_buffer_usage_syntax);

(II->

(

)) {

PP.

(

, diag::err_pp_double_begin_pragma_unsafe_buffer_usage);

}

(II->

(

)) {

PP.

(

, diag::err_pp_unmatched_end_begin_pragma_unsafe_buffer_usage);

PP.

(Tok, diag::err_pp_pragma_unsafe_buffer_usage_syntax);

PragmaDiagnosticHandler(

*NS)

&DiagToken)

{

(Tok.

(tok::identifier)) {

PP.

(Tok, diag::warn_pragma_diagnostic_invalid);

(II->

(

)) {

PP.

(Tok, diag::warn_pragma_diagnostic_cannot_pop);

(Tok.

(tok::eod))

PP.

(Tok.

(), diag::warn_pragma_diagnostic_invalid_token);

}

(II->

(

)) {

(Tok.

(tok::eod))

PP.

(Tok.

(), diag::warn_pragma_diagnostic_invalid_token);

.Case(

, diag::Severity::Ignored)

.Case(

, diag::Severity::Warning)

.Case(

, diag::Severity::Error)

.Case(

, diag::Severity::Fatal)

PP.

(Tok, diag::warn_pragma_diagnostic_invalid);

std::string WarningName;

(Tok.

(tok::eod)) {

PP.

(Tok.

(), diag::warn_pragma_diagnostic_invalid_token);

(WarningName.size() < 3 || WarningName[0] !=

||

(WarningName[1] !=

&& WarningName[1] !=

)) {

PP.

(StringLoc, diag::warn_pragma_diagnostic_invalid_option);

: diag::Flavor::Remark;

StringRef

= StringRef(WarningName).substr(2);

unknownDiag =

;

(Group ==

) {

PP.

(StringLoc, diag::warn_pragma_diagnostic_unknown_warning)

&DepToken)

{

&Tok)

{

(Tok.

(tok::l_paren)) {

PP.

(Tok, diag::warn_pragma_warning_expected) <<

;

(II && II->

(

)) {

(Tok.

(tok::comma)) {

(Tok.

(tok::numeric_constant) &&

(Level < 0 || Level > 4) {

PP.

(Tok, diag::warn_pragma_warning_push_level);

}

(II && II->

(

)) {

PP.

(Tok, diag::warn_pragma_diagnostic_cannot_pop);

(!II && !Tok.

(tok::numeric_constant)) {

PP.

(Tok, diag::warn_pragma_warning_spec_invalid);

SpecifierValid;

SpecifierInt = llvm::StringSwitch<int>(II->

())

SpecifierValid = SpecifierInt != -1;

((SpecifierValid = (

>= 1) && (

<= 4)))

SpecifierValid =

;

(!SpecifierValid) {

PP.

(Tok, diag::warn_pragma_warning_spec_invalid);

(Tok.

(tok::colon)) {

PP.

(Tok, diag::warn_pragma_warning_expected) <<

;

(Tok.

(tok::numeric_constant)) {

PP.

(Tok, diag::warn_pragma_warning_expected_number);

Ids.push_back(

(

));

SV = diag::Severity::Ignored;

(

: Ids) {

diag::Flavor::WarningOrError, *Group, SV, DiagLoc);

assert(!unknownDiag &&

);

(Tok.

(tok::semi))

(Tok.

(tok::r_paren)) {

PP.

(Tok, diag::warn_pragma_warning_expected) <<

;

(Tok.

(tok::eod))

PP.

(Tok, diag::ext_pp_extra_tokens_at_eol) <<

;

PragmaExecCharsetHandler() :

(

) {}

&Tok)

{

(Tok.

(tok::l_paren)) {

PP.

(Tok, diag::warn_pragma_exec_charset_expected) <<

;

(II && II->

(

)) {

(Tok.

(tok::comma)) {

std::string ExecCharset;

,

(ExecCharset !=

&& ExecCharset !=

) {

PP.

(Tok, diag::warn_pragma_exec_charset_push_invalid) << ExecCharset;

}

(II && II->

(

)) {

PP.

(Tok, diag::warn_pragma_exec_charset_spec_invalid);

(Tok.

(tok::r_paren)) {

PP.

(Tok, diag::warn_pragma_exec_charset_expected) <<

;

(Tok.

(tok::eod))

PP.

(Tok, diag::ext_pp_extra_tokens_at_eol) <<

;

PragmaIncludeAliasHandler() :

(

) {}

&IncludeAliasTok)

{

PragmaNameOnly =

) {

PragmaNameOnly ?

:

;

PragmaNameOnly ?

:

;

PragmaNameOnly ?

:

;

llvm_unreachable(

);

StringRef Namespace = StringRef())

&Tok)

{

ExpectClosingParen =

;

ExpectClosingParen =

;

tok::string_literal:

PP.

(MessageLoc, diag::err_pragma_message_malformed) <<

;

std::string MessageString;

(ExpectClosingParen) {

(Tok.

(tok::r_paren)) {

(Tok.

(tok::eod)) {

? diag::err_pragma_message

: diag::warn_pragma_message) << MessageString;

&Tok)

{

(Tok.

(tok::eod))

PP.

(Tok, diag::ext_pp_extra_tokens_at_eol) <<

;

tok::annot_module_include, Imported);

CB->moduleImport(ImportLoc, ModuleName, Imported);

&Tok)

{

(Tok.

(tok::eod))

PP.

(Tok, diag::ext_pp_extra_tokens_at_eol) <<

;

(ModuleName.front().first->getName() != Current) {

PP.

(ModuleName.front().second, diag::err_pp_module_begin_wrong_module)

<< ModuleName.front().first << (ModuleName.size() > 1)

<< Current.empty() << Current;

&MM = HSI.getModuleMap();

*M = HSI.lookupModule(Current, ModuleName.front().second);

PP.

(ModuleName.front().second,

diag::err_pp_module_begin_no_module_map) << Current;

(

I = 1; I != ModuleName.size(); ++I) {

PP.

(ModuleName[I].second, diag::err_pp_module_begin_no_submodule)

PP.

(BeginLoc, diag::note_pp_module_begin_here)

tok::annot_module_begin, M);

&Tok)

{

(Tok.

(tok::eod))

PP.

(Tok, diag::ext_pp_extra_tokens_at_eol) <<

;

PP.

(

, diag::err_pp_module_end_without_module_begin);

&Tok)

{

&Tok)

{

(Tok.

(tok::eod))

PP.

(Tok, diag::ext_pp_extra_tokens_at_eol) <<

;

PragmaPushMacroHandler() :

(

) {}

&PushMacroTok)

{

&PopMacroTok)

{

PragmaARCCFCodeAuditedHandler :

{

PragmaARCCFCodeAuditedHandler() :

(

) {}

&NameTok)

{

(BeginEnd && BeginEnd->

(

)) {

}

(BeginEnd && BeginEnd->

(

)) {

PP.

(Tok.

(), diag::err_pp_arc_cf_code_audited_syntax);

(Tok.

(tok::eod))

PP.

(Tok, diag::ext_pp_extra_tokens_at_eol) <<

;

PP.

(

, diag::err_pp_double_begin_of_arc_cf_code_audited);

PP.

(BeginLoc, diag::note_pragma_entered_here);

PP.

(

, diag::err_pp_unmatched_end_of_arc_cf_code_audited);

PragmaAssumeNonNullHandler() :

(

) {}

&NameTok)

{

(BeginEnd && BeginEnd->

(

)) {

}

(BeginEnd && BeginEnd->

(

)) {

(Tok.

(tok::eod))

PP.

(Tok, diag::ext_pp_extra_tokens_at_eol) <<

;

PP.

(

, diag::err_pp_double_begin_of_assume_nonnull);

PP.

(BeginLoc, diag::note_pragma_entered_here);

PP.

(

, diag::err_pp_unmatched_end_of_assume_nonnull);

PragmaRegionHandler(

*pragma) :

(pragma) {}

&NameTok)

{

std::string &MessageString) {

(Tok.

(tok::l_paren)) {

PP.

(Tok, diag::err_expected) <<

;

(!Tok.

(tok::identifier)) {

PP.

(Tok, diag::err_expected) << tok::identifier;

PP.

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

(Tok.

(tok::comma)) {

(Tok.

(tok::r_paren)) {

PP.

(Tok, diag::err_expected) <<

;

PragmaDeprecatedHandler() :

(

) {}

&Tok)

{

std::string MessageString;

PP, Tok,

, MessageString)) {

PragmaRestrictExpansionHandler :

{

PragmaRestrictExpansionHandler() :

(

) {}

&Tok)

{

std::string MessageString;

PP, Tok,

, MessageString)) {

&Tok)

{

(Tok.

(tok::l_paren)) {

PP.

(Tok, diag::err_expected) <<

;

(!Tok.

(tok::identifier)) {

PP.

(Tok, diag::err_expected) << tok::identifier;

PP.

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

(Tok.

(tok::r_paren)) {

PP.

(Tok, diag::err_expected) <<

;

Preprocessor::RegisterBuiltinPragmas() {

ModuleHandler->AddPragma(

PragmaModuleImportHandler());

ModuleHandler->AddPragma(

PragmaModuleBeginHandler());

ModuleHandler->AddPragma(

PragmaModuleEndHandler());

ModuleHandler->AddPragma(

PragmaModuleBuildHandler());

ModuleHandler->AddPragma(

PragmaModuleLoadHandler());

(LangOpts.MicrosoftExt) {

(

PragmaHandlerRegistry::entry &handler :

PragmaHandlerRegistry::entries()) {

Defines the Diagnostic-related interfaces.

enum clang::sema::@1704::IndirectLocalPathEntry::EntryKind Kind

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

Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.

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 LexModuleName(Preprocessor &PP, Token &Tok, llvm::SmallVectorImpl< std::pair< IdentifierInfo *, SourceLocation > > &ModuleName)

static bool LexModuleNameComponent(Preprocessor &PP, Token &Tok, std::pair< IdentifierInfo *, SourceLocation > &ModuleNameComponent, bool First)

Defines the PreprocessorLexer interface.

Defines the clang::Preprocessor interface.

Defines the clang::SourceLocation class and associated facilities.

Defines the SourceManager interface.

Defines the clang::TokenKind enum and support functions.

const NestedNameSpecifier * Specifier

void setSeverityForAll(diag::Flavor Flavor, diag::Severity Map, SourceLocation Loc=SourceLocation())

Add the specified mapping to all diagnostics of the specified flavor.

LLVM_DUMP_METHOD void dump() const

void pushMappings(SourceLocation Loc)

Copies the current DiagMappings and pushes the new copy onto the top of the stack.

bool setSeverityForGroup(diag::Flavor Flavor, StringRef Group, diag::Severity Map, SourceLocation Loc=SourceLocation())

Change an entire diagnostic group (e.g.

bool popMappings(SourceLocation Loc)

Pops the current DiagMappings off the top of the stack, causing the new top of the stack to be the ac...

EmptyPragmaHandler - A pragma handler which takes no action, which can be used to ignore particular p...

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) override

EmptyPragmaHandler(StringRef Name=StringRef())

time_t getModificationTime() const

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

void setIsRestrictExpansion(bool Val)

void setIsDeprecatedMacro(bool Val)

void setIsPoisoned(bool Value=true)

setIsPoisoned - Mark this identifier as poisoned.

void setIsFinal(bool Val)

bool hasMacroDefinition() const

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

bool isFromAST() const

Return true if the identifier in its current state was loaded from an AST file.

bool isPoisoned() const

Return true if this token has been poisoned.

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

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

void setChangedSinceDeserialization()

Note that this identifier has changed since it was loaded from an AST file.

StringRef getName() const

Return the actual identifier string.

std::string CurrentModule

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

Lexer - This provides a simple interface that turns a text buffer into a stream of tokens.

static Lexer * Create_PragmaLexer(SourceLocation SpellingLoc, SourceLocation ExpansionLocStart, SourceLocation ExpansionLocEnd, unsigned TokLen, Preprocessor &PP)

Create_PragmaLexer: Lexer constructor - Create a new lexer object for _Pragma expansion.

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

void setIsAllowRedefinitionsWithoutWarning(bool Val)

Set the value of the IsAllowRedefinitionsWithoutWarning flag.

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

Attempt to load the given module.

virtual void createModuleFromSource(SourceLocation Loc, StringRef ModuleName, StringRef Source)=0

Attempt to create the given module from the specified source buffer.

Module * lookupModuleQualified(StringRef Name, Module *Context) const

Retrieve a module with the given name within the given context, using direct (qualified) name lookup.

Module * findOrInferSubmodule(Module *Parent, StringRef Name)

llvm::iterator_range< module_iterator > modules() const

Describes a module or submodule.

StringRef getTopLevelModuleName() const

Retrieve the name of the top-level module.

llvm::iterator_range< submodule_iterator > submodules()

void dump() const

Dump the contents of this module to the given output stream.

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

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

This interface provides a way to observe the actions of the preprocessor as it does its thing.

virtual void PragmaExecCharsetPop(SourceLocation Loc)

Callback invoked when a #pragma execution_character_set(pop) directive is read.

virtual void PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace)

Callback invoked when a #pragma gcc diagnostic push directive is read.

virtual void PragmaWarning(SourceLocation Loc, PragmaWarningSpecifier WarningSpec, ArrayRef< int > Ids)

virtual void PragmaDebug(SourceLocation Loc, StringRef DebugType)

Callback invoked when a #pragma clang __debug directive is read.

virtual void PragmaDiagnostic(SourceLocation Loc, StringRef Namespace, diag::Severity mapping, StringRef Str)

Callback invoked when a #pragma gcc diagnostic directive is read.

PragmaWarningSpecifier

Callback invoked when a #pragma warning directive is read.

virtual void PragmaAssumeNonNullEnd(SourceLocation Loc)

Callback invoked when a #pragma clang assume_nonnull end directive is read.

virtual void PragmaAssumeNonNullBegin(SourceLocation Loc)

Callback invoked when a #pragma clang assume_nonnull begin directive is read.

virtual void PragmaMessage(SourceLocation Loc, StringRef Namespace, PragmaMessageKind Kind, StringRef Str)

Callback invoked when a #pragma message directive is read.

virtual void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str)

Callback invoked when a #pragma execution_character_set(push) directive is read.

virtual void PragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace)

Callback invoked when a #pragma gcc diagnostic pop directive is read.

virtual void PragmaWarningPop(SourceLocation Loc)

Callback invoked when a #pragma warning(pop) directive is read.

PragmaMessageKind

Determines the kind of #pragma invoking a call to PragmaMessage.

@ PMK_Warning

#pragma GCC warning has been invoked.

@ PMK_Error

#pragma GCC error has been invoked.

@ PMK_Message

#pragma message has been invoked.

virtual void PragmaWarningPush(SourceLocation Loc, int Level)

Callback invoked when a #pragma warning(push) directive is read.

PragmaHandler - Instances of this interface defined to handle the various pragmas that the language f...

StringRef getName() const

virtual void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken)=0

virtual PragmaNamespace * getIfNamespace()

getIfNamespace - If this is a namespace, return it.

PragmaNamespace - This PragmaHandler subdivides the namespace of pragmas, allowing hierarchical pragm...

void AddPragma(PragmaHandler *Handler)

AddPragma - Add a pragma to this namespace.

PragmaHandler * FindHandler(StringRef Name, bool IgnoreNull=true) const

FindHandler - Check to see if there is already a handler for the specified name.

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) override

void RemovePragmaHandler(PragmaHandler *Handler)

RemovePragmaHandler - Remove the given handler from the namespace.

PragmaNamespace * getIfNamespace() override

getIfNamespace - If this is a namespace, return it.

bool LexingRawMode

True if in raw mode.

bool ParsingPreprocessorDirective

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

OptionalFileEntryRef getFileEntry() const

getFileEntry - Return the FileEntry corresponding to this FileID.

bool DisablePragmaDebugCrash

Prevents intended crashes when using #pragma clang __debug. For testing.

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

void HandlePragmaPushMacro(Token &Tok)

Handle #pragma push_macro.

bool FinishLexStringLiteral(Token &Result, std::string &String, const char *DiagnosticTag, bool AllowMacroExpansion)

Complete the lexing of a string literal where the first token has already been lexed (see LexStringLi...

void HandlePragmaPoison()

HandlePragmaPoison - Handle #pragma GCC poison. PoisonTok is the 'poison'.

void dumpMacroInfo(const IdentifierInfo *II)

std::pair< IdentifierInfo *, SourceLocation > getPragmaARCCFCodeAuditedInfo() const

The location of the currently-active #pragma clang arc_cf_code_audited begin.

void HandlePragmaSystemHeader(Token &SysHeaderTok)

HandlePragmaSystemHeader - Implement #pragma GCC system_header.

void setPragmaARCCFCodeAuditedInfo(IdentifierInfo *Ident, SourceLocation Loc)

Set the location of the currently-active #pragma clang arc_cf_code_audited begin.

void HandlePragmaModuleBuild(Token &Tok)

void EnterToken(const Token &Tok, bool IsReinject)

Enters a token in the token stream to be lexed next.

void IgnorePragmas()

Install empty handlers for all pragmas (making them ignored).

PPCallbacks * getPPCallbacks() const

const MacroInfo * getMacroInfo(const IdentifierInfo *II) const

ArrayRef< BuildingSubmoduleInfo > getBuildingSubmodules() const

Get the list of submodules that we're currently building.

SourceLocation getModuleImportLoc(Module *M) const

void setPragmaAssumeNonNullLoc(SourceLocation Loc)

Set the location of the currently-active #pragma clang assume_nonnull begin.

bool isInPrimaryFile() const

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

void CreateString(StringRef Str, Token &Tok, SourceLocation ExpansionLocStart=SourceLocation(), SourceLocation ExpansionLocEnd=SourceLocation())

Plop the specified string into a scratch buffer and set the specified token's location and length to ...

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

void addMacroDeprecationMsg(const IdentifierInfo *II, std::string Msg, SourceLocation AnnotationLoc)

void addRestrictExpansionMsg(const IdentifierInfo *II, std::string Msg, SourceLocation AnnotationLoc)

IdentifierInfo * LookUpIdentifierInfo(Token &Identifier) const

Given a tok::raw_identifier token, look up the identifier information for the token and install it in...

void addFinalLoc(const IdentifierInfo *II, SourceLocation AnnotationLoc)

void makeModuleVisible(Module *M, SourceLocation Loc)

void Lex(Token &Result)

Lex the next token for this preprocessor.

const TranslationUnitKind TUKind

The kind of translation unit we are processing.

ModuleLoader & getModuleLoader() const

Retrieve the module loader associated with this preprocessor.

SourceRange DiscardUntilEndOfDirective()

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

bool LexOnOffSwitch(tok::OnOffSwitch &Result)

Lex an on-off-switch (C99 6.10.6p2) and verify that it is followed by EOD.

void HandlePragmaDependency(Token &DependencyTok)

HandlePragmaDependency - Handle #pragma GCC dependency "foo" blah.

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

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

bool enterOrExitSafeBufferOptOutRegion(bool isEnter, const SourceLocation &Loc)

Alter the state of whether this PP currently is in a "-Wunsafe-buffer-usage" opt-out region.

IdentifierInfo * getIdentifierInfo(StringRef Name) const

Return information about the specified preprocessor identifier token.

SourceManager & getSourceManager() const

void HandlePragmaOnce(Token &OnceTok)

HandlePragmaOnce - Handle #pragma once. OnceTok is the 'once'.

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 getPragmaAssumeNonNullLoc() const

The location of the currently-active #pragma clang assume_nonnull begin.

const TargetInfo & getTargetInfo() const

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

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

PreprocessorOptions & getPreprocessorOpts() const

Retrieve the preprocessor options used to initialize this preprocessor.

bool parseSimpleIntegerLiteral(Token &Tok, uint64_t &Value)

Parses a simple integer literal to get its numeric value.

void LexUnexpandedToken(Token &Result)

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

bool creatingPCHWithPragmaHdrStop()

True if creating a PCH with a #pragma hdrstop.

void AddPragmaHandler(StringRef Namespace, PragmaHandler *Handler)

Add the specified pragma handler to this preprocessor.

llvm::BumpPtrAllocator & getPreprocessorAllocator()

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 HandlePragmaPopMacro(Token &Tok)

Handle #pragma pop_macro.

Module * LeaveSubmodule(bool ForPragma)

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

IdentifierInfo * ParsePragmaPushOrPopMacro(Token &Tok)

ParsePragmaPushOrPopMacro - Handle parsing of pragma push_macro/pop_macro.

bool usingPCHWithPragmaHdrStop()

True if using a PCH with a #pragma hdrstop.

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

void HandlePragmaMark(Token &MarkTok)

void HandlePragmaHdrstop(Token &Tok)

DiagnosticsEngine & getDiagnostics() const

void RemovePragmaHandler(StringRef Namespace, PragmaHandler *Handler)

Remove the specific pragma handler from this preprocessor.

void HandlePragmaIncludeAlias(Token &Tok)

DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const

Forwarding function for diagnostics.

bool LexStringLiteral(Token &Result, std::string &String, const char *DiagnosticTag, bool AllowMacroExpansion)

Lex a string literal, which may be the concatenation of multiple string literals and may even come fr...

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.

const char * getFilename() const

Return the presumed filename of this location.

unsigned getLine() const

Return the presumed line number of this location.

bool isInvalid() const

Return true if this object is invalid or uninitialized.

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

void print(raw_ostream &OS, const SourceManager &SM) const

void noteSLocAddressSpaceUsage(DiagnosticsEngine &Diag, std::optional< unsigned > MaxNotes=32) const

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.

PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const

Returns the "presumed" location of a SourceLocation specifies.

unsigned getLineTableFilenameID(StringRef Str)

Return the uniqued ID for the specified filename.

A trivial tuple used to represent a source range.

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

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

IdentifierInfo * getIdentifierInfo() const

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 isNot(tok::TokenKind K) const

bool isAnnotation() const

Return true if this is any of tok::annot_* kind tokens.

bool hasUDSuffix() const

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

void setAnnotationRange(SourceRange R)

void startToken()

Reset all flags to cleared.

StringRef getRawIdentifier() const

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

uint32_t Literal

Literals are represented as positive integers.

Flavor

Flavors of diagnostics we can emit.

Severity

Enum values that allow the client to map NOTEs, WARNINGs, and EXTENSIONs to either Ignore (nothing),...

bool Sub(InterpState &S, CodePtr OpPC)

bool isStringLiteral(TokenKind K)

Return true if this is a C or C++ string-literal (or C++11 user-defined-string-literal) token.

OnOffSwitch

Defines the possible values of an on-off-switch (C99 6.10.6p2).

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

std::optional< diag::Group > diagGroupFromCLWarningID(unsigned)

For cl.exe warning IDs that cleany map to clang diagnostic groups, returns the corresponding group.

@ Result

The result type of a method or function.

@ TU_Prefix

The translation unit is a prefix to a translation unit, and is not complete.

@ PIK__Pragma

The pragma was introduced via the C99 _Pragma(string-literal).

@ PIK___pragma

The pragma was introduced via the Microsoft __pragma(token-string).

void prepare_PragmaString(SmallVectorImpl< char > &StrVal)

Destringize a _Pragma("") string according to C11 6.10.9.1: "The string literal is destringized by de...

const FunctionProtoType * T

Describes how and where the pragma was introduced.

PragmaIntroducerKind Kind

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