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

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

clang: lib/Basic/Diagnostic.cpp Source File

;

StringRef Modifier, StringRef Argument,

StringRef Str =

;

Output.append(Str.begin(), Str.end());

: Diags(

::move(diags)), DiagOpts(

::move(DiagOpts)) {

DiagStatesByLoc.dump(*SourceMgr);

DiagStatesByLoc.dump(*SourceMgr, DiagName);

ShouldOwnClient) {

Owner.reset(ShouldOwnClient ? client :

);

DiagStateOnPushStack.push_back(GetCurDiagState());

(DiagStateOnPushStack.empty())

(DiagStateOnPushStack.back() != GetCurDiagState()) {

PushDiagStatePoint(DiagStateOnPushStack.back(),

);

DiagStateOnPushStack.pop_back();

ErrorOccurred =

;

UncompilableErrorOccurred =

;

FatalErrorOccurred =

;

UnrecoverableErrorOccurred =

;

TrapNumErrorsOccurred = 0;

TrapNumUnrecoverableErrorsOccurred = 0;

DiagStatesByLoc.clear();

DiagStateOnPushStack.clear();

DiagStates.emplace_back(*Diags);

DiagStatesByLoc.appendFirst(&DiagStates.back());

DiagnosticsEngine::DiagState::getOrAddMapping(

) {

std::pair<iterator, bool>

=

.first->second = DiagIDs.getDefaultMapping(

);

DiagIDs.initCustomDiagMapping(

.first->second,

);

.first->second;

DiagnosticsEngine::DiagStateMap::appendFirst(DiagState *State) {

assert(Files.empty() &&

);

FirstDiagState = CurDiagState = State;

DiagnosticsEngine::DiagStateMap::append(

&SrcMgr,

CurDiagState = State;

CurDiagStateLoc =

;

Offset = Decomp.second;

(

*F = getFile(SrcMgr, Decomp.first); F;

Offset = F->ParentOffset, F = F->Parent) {

F->HasLocalTransitions =

;

&

= F->StateTransitions.back();

assert(

.Offset <= Offset &&

);

(

.Offset == Offset) {

(

.State == State)

F->StateTransitions.push_back({State, Offset});

DiagnosticsEngine::DiagState *

DiagnosticsEngine::DiagStateMap::lookup(

&SrcMgr,

FirstDiagState;

*F = getFile(SrcMgr, Decomp.first);

F->lookup(Decomp.second);

DiagnosticsEngine::DiagState *

DiagnosticsEngine::DiagStateMap::File::lookup(

Offset)

{

llvm::partition_point(StateTransitions, [=](

DiagStatePoint &

) {

.Offset <= Offset;

assert(OnePastIt != StateTransitions.begin() &&

);

OnePastIt[-1].State;

DiagnosticsEngine::DiagStateMap::File *

DiagnosticsEngine::DiagStateMap::getFile(

&SrcMgr,

= Files.equal_range(ID);

&

.first->second;

&F = Files.insert(

.first, std::make_pair(ID,

()))->second;

(

.isValid()) {

F.Parent = getFile(SrcMgr, Decomp.first);

F.ParentOffset = Decomp.second;

F.StateTransitions.push_back({F.Parent->lookup(Decomp.second), 0});

F.StateTransitions.push_back({FirstDiagState, 0});

DiagnosticsEngine::DiagStateMap::dump(

&SrcMgr,

StringRef DiagName)

{

llvm::errs() <<

;

CurDiagStateLoc.print(llvm::errs(), SrcMgr);

llvm::errs() <<

<< CurDiagState <<

;

(

&F : Files) {

PrintedOuterHeading =

;

PrintOuterHeading = [&] {

(PrintedOuterHeading)

;

PrintedOuterHeading =

;

llvm::errs() <<

<< &

<<

<<

.getHashValue()

(F.second.Parent) {

std::pair<FileID, unsigned> Decomp =

assert(

.ParentOffset == Decomp.second);

llvm::errs() <<

<<

.Parent <<

<< Decomp.first.getHashValue() <<

;

.

(llvm::errs(), SrcMgr);

(

.HasLocalTransitions)

llvm::errs() <<

;

llvm::errs() <<

;

(DiagName.empty())

(DiagStatePoint &Transition :

.StateTransitions) {

PrintedInnerHeading =

;

PrintInnerHeading = [&] {

(PrintedInnerHeading)

;

PrintedInnerHeading =

;

llvm::errs() <<

;

.

(llvm::errs(), SrcMgr);

llvm::errs() <<

<< Transition.State <<

;

(DiagName.empty())

(

&Mapping : *Transition.State) {

(!DiagName.empty() && DiagName != Option)

llvm::errs() <<

;

llvm::errs() <<

<< Mapping.first <<

;

llvm::errs() << Option;

llvm::errs() <<

;

(Mapping.second.getSeverity()) {

(!Mapping.second.isUser())

llvm::errs() <<

;

(Mapping.second.isPragma())

llvm::errs() <<

;

(Mapping.second.hasNoWarningAsError())

llvm::errs() <<

;

(Mapping.second.hasNoErrorAsFatal())

llvm::errs() <<

;

(Mapping.second.wasUpgradedFromWarning())

llvm::errs() <<

;

llvm::errs() <<

;

DiagnosticsEngine::PushDiagStatePoint(DiagState *State,

assert(

.

() &&

);

DiagStatesByLoc.append(*SourceMgr,

, State);

assert((Diags->isWarningOrExtension(

) ||

);

assert((L.

() || SourceMgr) &&

);

WasUpgradedFromWarning =

;

WasUpgradedFromWarning =

;

((L.

() || L == DiagStatesByLoc.getCurDiagStateLoc()) &&

DiagStatesByLoc.getCurDiagState()) {

DiagStatesByLoc.getCurDiagState()->setMapping(

, Mapping);

DiagStates.push_back(*GetCurDiagState());

DiagStates.back().setMapping(

, Mapping);

PushDiagStatePoint(&DiagStates.back(), L);

(Diags->getDiagnosticsInGroup(Flavor, Group, GroupDiags))

Diags->setGroupSeverity(Group, Map);

std::vector<diag::kind> AllDiags;

(Diags->isWarningOrExtension(

))

WarningsSpecialCaseList :

llvm::SpecialCaseList {

std::unique_ptr<WarningsSpecialCaseList>

create(

llvm::MemoryBuffer &Input, std::string &Err);

globsMatches(

llvm::StringMap<Matcher> &CategoriesToMatchers,

StringRef FilePath)

;

llvm::DenseMap<diag::kind, const Section *> DiagToSection;

std::unique_ptr<WarningsSpecialCaseList>

WarningsSpecialCaseList::create(

llvm::MemoryBuffer &Input,

WarningSuppressionList = std::make_unique<WarningsSpecialCaseList>();

(!WarningSuppressionList->createInternal(&Input, Err))

WarningSuppressionList;

Sections.erase(

);

std::vector<std::pair<unsigned, const llvm::StringMapEntry<Section> *>>

LineAndSectionEntry.reserve(Sections.size());

(

&Entry : Sections) {

StringRef DiagName = Entry.getKey();

&DiagSectionMatcher = Entry.getValue().SectionMatcher;

DiagLine = DiagSectionMatcher->Globs.at(DiagName).second;

LineAndSectionEntry.emplace_back(DiagLine, &Entry);

llvm::sort(LineAndSectionEntry);

(

&[_, SectionEntry] : LineAndSectionEntry) {

StringRef DiagGroup = SectionEntry->getKey();

WarningFlavor, DiagGroup, GroupDiags)) {

StringRef Suggestion =

Diags.

(diag::warn_unknown_diag_option)

<<

(WarningFlavor) << DiagGroup

<< !Suggestion.empty() << Suggestion;

DiagToSection[

] = &SectionEntry->getValue();

WarningSuppressionList = WarningsSpecialCaseList::create(Input,

);

(!WarningSuppressionList) {

(diag::err_drv_malformed_warning_suppression_mapping)

<< Input.getBufferIdentifier() <<

;

WarningSuppressionList->processSections(*

);

DiagSuppressionMapping =

[WarningSuppressionList(std::move(WarningSuppressionList))](

WarningSuppressionList->isDiagSuppressed(DiagId, DiagLoc,

);

WarningsSpecialCaseList::isDiagSuppressed(

DiagId,

Section *DiagSection = DiagToSection.lookup(DiagId);

SectionEntries &EntityTypeToCategories = DiagSection->Entries;

SrcEntriesIt = EntityTypeToCategories.find(

);

(SrcEntriesIt == EntityTypeToCategories.end())

llvm::StringMap<llvm::SpecialCaseList::Matcher> &CategoriesToMatchers =

SrcEntriesIt->getValue();

(

PLoc =

.getPresumedLoc(DiagLoc); PLoc.isValid())

CategoriesToMatchers,

llvm::sys::path::remove_leading_dotslash(PLoc.getFilename()));

WarningsSpecialCaseList::globsMatches(

llvm::StringMap<Matcher> &CategoriesToMatchers,

StringRef FilePath)

{

StringRef LongestMatch;

LongestIsPositive =

;

(

&Entry : CategoriesToMatchers) {

StringRef

= Entry.getKey();

llvm::SpecialCaseList::Matcher &Matcher = Entry.getValue();

IsPositive =

!=

;

(

&[Pattern, Glob] : Matcher.Globs) {

(Pattern.size() < LongestMatch.size())

(!Glob.first.match(FilePath))

LongestMatch = Pattern;

LongestIsPositive = IsPositive;

LongestIsPositive;

assert(Client &&

);

assert(

() &&

);

Diags->EmitDiag(*

, DB, DiagLevel);

Emitted = ProcessDiag(DB);

DiagLoc(DiagLoc), DiagID(DiagID), IsActive(

) {

assert(DiagObj &&

);

DiagLoc =

.DiagLoc;

FlagValue =

.FlagValue;

DiagObj =

.DiagObj;

.DiagStorage =

;

IsActive =

.IsActive;

IsForceEmit =

.IsForceEmit;

: DiagObj(DO), DiagLoc(DiagBuilder.DiagLoc), DiagID(DiagBuilder.DiagID),

FlagValue(DiagBuilder.FlagValue), DiagStorage(*DiagBuilder.

()) {

StringRef StoredDiagMessage)

: DiagObj(DO), DiagLoc(DiagLoc), DiagID(DiagID), DiagStorage(DiagStorage),

StoredDiagMessage(StoredDiagMessage) {}

<std::

StrLen>

(

*Modifier,

ModifierLen,

(&Str)[StrLen]) {

StrLen-1 == ModifierLen && memcmp(Modifier, Str, StrLen-1) == 0;

( ; I !=

; ++I) {

(Depth == 0 && *I ==

)

I;

(Depth != 0 && *I ==

) Depth--;

(I++; I !=

&& !

(*I) && *I !=

; I++) ;

*Argument,

ArgumentLen,

*ArgumentEnd = Argument+ArgumentLen;

*NextVal =

(Argument, ArgumentEnd,

);

assert(NextVal != ArgumentEnd &&

);

Argument = NextVal+1;

*EndPtr =

(Argument, ArgumentEnd,

);

OutStr.push_back(

);

assert(ValNo != 0 &&

);

llvm::raw_svector_ostream Out(OutStr);

Out << ValNo << llvm::getOrdinalSuffix(ValNo);

std::array<std::pair<int64_t, char>, 4> Units = {

{{1'000'000'000'000L,

},

{1'000'000'000L,

},

llvm::raw_svector_ostream Out(OutStr);

(

&[UnitSize, UnitSign] : Units) {

(ValNo >= UnitSize) {

Out << llvm::format(

, ValNo /

(UnitSize),

(Start != End && *Start >=

&& *Start <=

) {

Val += *Start -

;

(*Start !=

) {

assert(*Start ==

&&

);

assert(*Start ==

&&

);

Low <= Val && Val <= High;

(

ValNo,

*Start,

*End) {

assert(*Start ==

&&

);

ValMod = ValNo % Arg;

assert((

==

|| (

>=

&&

<=

)) &&

);

Start = std::find(Start, End,

);

*Argument,

ArgumentLen,

*ArgumentEnd = Argument + ArgumentLen;

assert(Argument < ArgumentEnd &&

);

*ExprEnd = Argument;

(*ExprEnd !=

) {

assert(ExprEnd != ArgumentEnd &&

);

Argument = ExprEnd + 1;

ExprEnd =

(Argument, ArgumentEnd,

);

Argument =

(Argument, ArgumentEnd - 1,

) + 1;

tok::identifier:

;

(StoredDiagMessage.has_value()) {

OutStr.append(StoredDiagMessage->begin(), StoredDiagMessage->end());

OutStr.reserve(OutStr.size() + Str.size());

*

=

*

(Str.data());

llvm::raw_svector_ostream OutStream(OutStr);

*End =

+ Str.size();

(

!= End) {

OutStream << *

;

(llvm::isLegalUTF8Sequence(

, End)) {

llvm::UTF32 CodepointValue;

llvm::UTF32 *CpPtr = &CodepointValue;

*CodepointBegin =

;

*CodepointEnd =

llvm::ConversionResult Res = llvm::ConvertUTF8toUTF32(

&

, CodepointEnd, &CpPtr, CpPtr + 1, llvm::strictConversion);

llvm::conversionOK == Res &&

);

assert(

== CodepointEnd &&

);

(llvm::sys::unicode::isPrintable(CodepointValue) ||

llvm::sys::unicode::isFormatting(CodepointValue)) {

OutStr.append(CodepointBegin, CodepointEnd);

OutStream <<

<< llvm::format_hex_no_prefix(CodepointValue, 4,

)

OutStream <<

<< llvm::format_hex_no_prefix(*

, 2,

) <<

;

(DiagEnd - DiagStr == 2 && StringRef(DiagStr, DiagEnd - DiagStr) ==

&&

(

i = 0, e =

(); i < e; ++i)

(DiagStr != DiagEnd) {

(DiagStr[0] !=

) {

*StrEnd = std::find(DiagStr, DiagEnd,

);

OutStr.append(DiagStr, StrEnd);

OutStr.push_back(DiagStr[1]);

*Modifier =

, *Argument =

;

ModifierLen = 0, ArgumentLen = 0;

(DiagStr[0] ==

||

(DiagStr[0] >=

&& DiagStr[0] <=

))

ModifierLen = DiagStr-Modifier;

(DiagStr[0] ==

) {

DiagStr =

(DiagStr, DiagEnd,

);

assert(DiagStr != DiagEnd &&

);

ArgumentLen = DiagStr-Argument;

assert(

(*DiagStr) &&

);

ArgNo = *DiagStr++ -

;

ArgNo2 = ArgNo;

(

(Modifier, ModifierLen,

)) {

assert(*DiagStr ==

&&

(*(DiagStr + 1)) &&

);

ArgNo2 = *DiagStr++ -

;

*ArgumentEnd = Argument + ArgumentLen;

assert(

(

+ 1, ArgumentEnd,

) == ArgumentEnd &&

);

*SecondDollar =

(FirstDollar + 1,

,

);

ArgStr1[] = {

,

(

+ ArgNo) };

ArgStr2[] = {

,

(

+ ArgNo2) };

assert(ModifierLen == 0 &&

);

assert(ModifierLen == 0 &&

);

(

(Modifier, ModifierLen,

)) {

}

(

(Modifier, ModifierLen,

)) {

}

(

(Modifier, ModifierLen,

)) {

}

(

(Modifier, ModifierLen,

)) {

}

(

(Modifier, ModifierLen,

)) {

assert(ModifierLen == 0 &&

);

llvm::raw_svector_ostream(OutStr) << Val;

(

(Modifier, ModifierLen,

)) {

}

(

(Modifier, ModifierLen,

)) {

}

(

(Modifier, ModifierLen,

)) {

}

(

(Modifier, ModifierLen,

)) {

}

(

(Modifier, ModifierLen,

)) {

assert(ModifierLen == 0 &&

);

llvm::raw_svector_ostream(OutStr) << Val;

assert(ModifierLen == 0 &&

);

llvm::raw_svector_ostream Out(OutStr);

Out <<

<< S <<

;

Out <<

<< S <<

;

assert(ModifierLen == 0 &&

);

*S =

;

OutStr.append(S, S + strlen(S));

llvm::raw_svector_ostream(OutStr) <<

<< II->

() <<

;

StringRef(Modifier, ModifierLen),

StringRef(Argument, ArgumentLen),

OutStr, QualTypeVals);

*ArgumentEnd = Argument + ArgumentLen;

(

()->PrintTemplateTree &&

.empty()) {

StringRef(Modifier, ModifierLen),

StringRef(Argument, ArgumentLen),

, QualTypeVals);

(!

.empty()) {

*FirstDollar =

(Argument, ArgumentEnd,

);

*SecondDollar =

(FirstDollar + 1, ArgumentEnd,

);

StringRef(Modifier, ModifierLen),

StringRef(Argument, ArgumentLen),

OutStr, QualTypeVals);

StringRef(Modifier, ModifierLen),

StringRef(Argument, ArgumentLen),

OutStr, QualTypeVals);

FormattedArgs.push_back(std::make_pair(Kind,

(ArgNo)));

OutStr.append(

.begin(),

.end());

: ID(ID), Level(Level), Message(Message) {}

: ID(Info.getID()), Level(Level) {

);

this->Message.assign(Message.begin(), Message.end());

: ID(ID), Level(Level),

(

), Message(Message),

Ranges(Ranges.begin(), Ranges.end()), FixIts(FixIts.begin(), FixIts.end())

IgnoringDiagConsumer::anchor() {}

.HandleDiagnostic(DiagLevel, Info);

.IncludeInDiagnosticCounts();

(

I = 0; I != NumCached; ++I)

FreeList[I] = Cached + I;

NumFreeListEntries = NumCached;

assert((NumFreeListEntries == NumCached ||

llvm::CrashRecoveryContext::isRecoveringFromCrash()) &&

);

static const char * ScanFormat(const char *I, const char *E, char Target)

ScanForward - Scans forward, looking for the given character, skipping nested clauses and escaped cha...

static void HandlePluralModifier(const Diagnostic &DInfo, unsigned ValNo, const char *Argument, unsigned ArgumentLen, SmallVectorImpl< char > &OutStr)

HandlePluralModifier - Handle the integer 'plural' modifier.

static void HandleIntegerSModifier(unsigned ValNo, SmallVectorImpl< char > &OutStr)

HandleIntegerSModifier - Handle the integer 's' modifier.

static void DummyArgToStringFn(DiagnosticsEngine::ArgumentKind AK, intptr_t QT, StringRef Modifier, StringRef Argument, ArrayRef< DiagnosticsEngine::ArgumentValue > PrevArgs, SmallVectorImpl< char > &Output, void *Cookie, ArrayRef< intptr_t > QualTypeVals)

static bool EvalPluralExpr(unsigned ValNo, const char *Start, const char *End)

EvalPluralExpr - Actual expression evaluator for HandlePluralModifier.

static void HandleIntegerHumanModifier(int64_t ValNo, SmallVectorImpl< char > &OutStr)

static unsigned PluralNumber(const char *&Start, const char *End)

PluralNumber - Parse an unsigned integer and advance Start.

static void HandleSelectModifier(const Diagnostic &DInfo, unsigned ValNo, const char *Argument, unsigned ArgumentLen, SmallVectorImpl< char > &OutStr)

HandleSelectModifier - Handle the integer 'select' modifier.

static bool ModifierIs(const char *Modifier, unsigned ModifierLen, const char(&Str)[StrLen])

ModifierIs - Return true if the specified modifier matches specified string.

static bool TestPluralRange(unsigned Val, const char *&Start, const char *End)

TestPluralRange - Test if Val is in the parsed range. Modifies Start.

static void HandleOrdinalModifier(unsigned ValNo, SmallVectorImpl< char > &OutStr)

HandleOrdinalModifier - Handle the integer 'ord' modifier.

static const char * getTokenDescForDiagnostic(tok::TokenKind Kind)

Returns the friendly description for a token kind that will appear without quotes in diagnostic messa...

Defines the Diagnostic-related interfaces.

static llvm::GlobalValue::DLLStorageClassTypes getStorage(CodeGenModule &CGM, StringRef Name)

Defines the Diagnostic IDs-related interfaces.

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

static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)

Produce a diagnostic highlighting some portion of a literal.

llvm::MachO::Target Target

Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.

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.

Defines the SourceManager interface.

Defines various enumerations that describe declaration and type specifiers.

Defines the clang::TokenKind enum and support functions.

A little helper class used to produce diagnostics.

Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...

virtual ~DiagnosticConsumer()

virtual void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info)

Handle this diagnostic, reporting it to the user or capturing it to a log as needed.

unsigned NumErrors

Number of errors reported.

unsigned NumWarnings

Number of warnings reported.

virtual bool IncludeInDiagnosticCounts() const

Indicates whether the diagnostics handled by this DiagnosticConsumer should be included in the number...

static StringRef getNearestOption(diag::Flavor Flavor, StringRef Group)

Get the diagnostic option with the closest edit distance to the given group name.

static bool IsCustomDiag(diag::kind Diag)

Level

The level of the diagnostic, after it has been through mapping.

static void getAllDiagnostics(diag::Flavor Flavor, std::vector< diag::kind > &Diags)

Get the set of all diagnostic IDs.

void setNoWarningAsError(bool Value)

void setSeverity(diag::Severity Value)

diag::Severity getSeverity() const

void setUpgradedFromWarning(bool Value)

void setNoErrorAsFatal(bool Value)

bool hasNoWarningAsError() const

A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine a...

Diagnostic(const DiagnosticsEngine *DO, const DiagnosticBuilder &DiagBuilder)

const SourceLocation & getLocation() const

const std::string & getArgStdStr(unsigned Idx) const

Return the provided argument string specified by Idx.

void FormatDiagnostic(SmallVectorImpl< char > &OutStr) const

Format this diagnostic into a string, substituting the formal arguments into the %0 slots.

uint64_t getRawArg(unsigned Idx) const

Return the specified non-string argument in an opaque form.

const char * getArgCStr(unsigned Idx) const

Return the specified C string argument.

const IdentifierInfo * getArgIdentifier(unsigned Idx) const

Return the specified IdentifierInfo argument.

SourceManager & getSourceManager() const

ArrayRef< FixItHint > getFixItHints() const

unsigned getNumArgs() const

bool hasSourceManager() const

DiagnosticsEngine::ArgumentKind getArgKind(unsigned Idx) const

Return the kind of the specified index.

int64_t getArgSInt(unsigned Idx) const

Return the specified signed integer argument.

uint64_t getArgUInt(unsigned Idx) const

Return the specified unsigned integer argument.

ArrayRef< CharSourceRange > getRanges() const

Return an array reference for this diagnostic's ranges.

const DiagnosticsEngine * getDiags() const

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

bool EmitDiagnostic(const DiagnosticBuilder &DB, bool Force=false)

Emit the diagnostic.

void setDiagSuppressionMapping(llvm::MemoryBuffer &Input)

Diagnostic suppression mappings can be used to suppress specific diagnostics in specific files.

bool isSuppressedViaMapping(diag::kind DiagId, SourceLocation DiagLoc) const

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 setClient(DiagnosticConsumer *client, bool ShouldOwnClient=true)

Set the diagnostic client associated with this diagnostic object.

SourceManager & getSourceManager() const

void pushMappings(SourceLocation Loc)

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

void setSeverity(diag::kind Diag, diag::Severity Map, SourceLocation Loc)

This allows the client to specify that certain warnings are ignored.

Level

The level of the diagnostic, after it has been through mapping.

DiagnosticConsumer * getClient()

@ ak_nameddecl

NamedDecl *.

@ ak_declcontext

DeclContext *.

@ ak_addrspace

address space

@ ak_identifierinfo

IdentifierInfo.

@ ak_qualtype_pair

pair<QualType, QualType>

@ ak_c_string

const char *

@ ak_declarationname

DeclarationName.

@ ak_tokenkind

enum TokenKind : unsigned

@ ak_std_string

std::string

@ ak_nestednamespec

NestedNameSpecifier *.

Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const

Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...

DiagnosticsEngine(IntrusiveRefCntPtr< DiagnosticIDs > Diags, IntrusiveRefCntPtr< DiagnosticOptions > DiagOpts, DiagnosticConsumer *client=nullptr, bool ShouldOwnClient=true)

bool setDiagnosticGroupErrorAsFatal(StringRef Group, bool Enabled)

Set the error-as-fatal flag for the given diagnostic group.

bool setDiagnosticGroupWarningAsError(StringRef Group, bool Enabled)

Set the warning-as-error flag for the given diagnostic group.

void ConvertArgToString(ArgumentKind Kind, intptr_t Val, StringRef Modifier, StringRef Argument, ArrayRef< ArgumentValue > PrevArgs, SmallVectorImpl< char > &Output, ArrayRef< intptr_t > QualTypeVals) const

Converts a diagnostic argument (as an intptr_t) into the string that represents it.

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...

const IntrusiveRefCntPtr< DiagnosticIDs > & getDiagnosticIDs() const

void Reset(bool soft=false)

Reset the state of the diagnostic object to its initial configuration.

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

bool IncludeInDiagnosticCounts() const override

Indicates whether the diagnostics handled by this DiagnosticConsumer should be included in the number...

~ForwardingDiagnosticConsumer() override

void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) override

Handle this diagnostic, reporting it to the user or capturing it to a log as needed.

A SourceLocation and its associated SourceManager.

bool hasManager() const

Checks whether the SourceManager is present.

const SourceManager & getManager() const

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

StringRef getName() const

Return the actual identifier string.

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

Encodes a location in the source.

std::string printToString(const SourceManager &SM) const

bool isValid() const

Return true if this is a valid SourceLocation object.

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

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.

DiagnosticsEngine & getDiagnostics() const

llvm::MemoryBufferRef getBufferOrFake(FileID FID, SourceLocation Loc=SourceLocation()) const

Return the buffer for the specified FileID.

std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const

Decompose the specified location into a raw FileID + Offset pair.

SourceLocation getLocForStartOfFile(FileID FID) const

Return the source location corresponding to the first byte of the specified file.

std::pair< FileID, unsigned > getDecomposedIncludedLoc(FileID FID) const

Returns the "included/expanded in" decomposed location of the given FileID.

Represents a diagnostic in a form that can be retained until its corresponding source manager is dest...

range_iterator range_begin() const

StoredDiagnostic()=default

DiagnosticsEngine::Level getLevel() const

fixit_iterator fixit_begin() const

const FullSourceLoc & getLocation() const

range_iterator range_end() const

StringRef getMessage() const

fixit_iterator fixit_end() const

The streaming interface shared between DiagnosticBuilder and PartialDiagnostic.

DiagStorageAllocator * Allocator

Allocator used to allocate storage for this diagnostic.

DiagnosticStorage * DiagStorage

void AddString(StringRef V) const

Flavor

Flavors of diagnostics we can emit.

@ WarningOrError

A diagnostic that indicates a problem or potential problem.

Severity

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

@ Warning

Present this diagnostic as a warning.

@ Fatal

Present this diagnostic as a fatal error.

@ Error

Present this diagnostic as an error.

@ Remark

Present this diagnostic as a remark.

@ Ignored

Do not present this diagnostic, ignore it.

const char * getTokenName(TokenKind Kind) LLVM_READNONE

Determines the name of a token as used within the front end.

const char * getKeywordSpelling(TokenKind Kind) LLVM_READNONE

Determines the spelling of simple keyword and contextual keyword tokens like 'int' and 'dynamic_cast'...

TokenKind

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

const char * getPunctuatorSpelling(TokenKind Kind) LLVM_READNONE

Determines the spelling of simple punctuation tokens like '!' or '', and returns NULL for literal and...

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

LLVM_READONLY bool isPrintable(unsigned char c)

Return true if this character is an ASCII printable character; that is, a character that should take ...

const StreamingDiagnostic & operator<<(const StreamingDiagnostic &DB, const ASTContext::SectionInfo &Section)

Insertion operator for diagnostics.

@ Result

The result type of a method or function.

llvm::StringRef getNullabilitySpelling(NullabilityKind kind, bool isContextSensitive=false)

Retrieve the spelling of the given nullability kind.

void EscapeStringForDiagnostic(StringRef Str, SmallVectorImpl< char > &OutStr)

EscapeStringForDiagnostic - Append Str to the diagnostic buffer, escaping non-printable characters an...

LLVM_READONLY bool isDigit(unsigned char c)

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

LLVM_READONLY bool isWhitespace(unsigned char c)

Return true if this character is horizontal or vertical ASCII whitespace: ' ', '\t',...

std::pair< NullabilityKind, bool > DiagNullabilityKind

A nullability kind paired with a bit indicating whether it used a context-sensitive keyword.

LLVM_READONLY bool isPunctuation(unsigned char c)

Return true if this character is an ASCII punctuation character.

__INTPTR_TYPE__ intptr_t

A signed integer type with the property that any valid pointer to void can be converted to this type,...

SmallVector< CharSourceRange, 8 > DiagRanges

The list of ranges added to this diagnostic.

SmallVector< FixItHint, 6 > FixItHints

If valid, provides a hint with some code to insert, remove, or modify at a particular position.

unsigned TemplateDiffUsed

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