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

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

clang: lib/Frontend/PrintPreprocessedOutput.cpp Source File

;

*OS <<

<< II.

();

(; AI+1 !=

; ++AI) {

*OS << (*AI)->getName();

((*AI)->getName() ==

)

*OS << (*AI)->getName();

(

&

: MI.

()) {

(

.hasLeadingSpace())

PrintPPOutputPPCallbacks :

{

EmittedTokensOnThisLine;

EmittedDirectiveOnThisLine;

DisableLineMarkers;

DumpIncludeDirectives;

DumpEmbedDirectives;

UseLineDirectives;

IsFirstFileEntered;

MinimizeWhitespace;

KeepSystemIncludes;

std::unique_ptr<llvm::raw_null_ostream> NullOS;

NumToksToSkip;

PrintPPOutputPPCallbacks(

&pp, raw_ostream *os,

lineMarkers,

defines,

DumpIncludeDirectives,

DumpEmbedDirectives,

UseLineDirectives,

MinimizeWhitespace,

DirectivesOnly,

KeepSystemIncludes)

: PP(pp),

(PP.getSourceManager()), ConcatInfo(PP), OS(os),

DisableLineMarkers(lineMarkers), DumpDefines(defines),

DumpIncludeDirectives(DumpIncludeDirectives),

DumpEmbedDirectives(DumpEmbedDirectives),

UseLineDirectives(UseLineDirectives),

MinimizeWhitespace(MinimizeWhitespace), DirectivesOnly(DirectivesOnly),

KeepSystemIncludes(KeepSystemIncludes), OrigOS(os), NumToksToSkip(0) {

CurFilename +=

;

EmittedTokensOnThisLine =

;

EmittedDirectiveOnThisLine =

;

IsFirstFileEntered =

;

(KeepSystemIncludes)

NullOS = std::make_unique<llvm::raw_null_ostream>();

expandEmbedContents()

{

!DumpEmbedDirectives; }

isMinimizeWhitespace()

{

MinimizeWhitespace; }

setEmittedTokensOnThisLine() { EmittedTokensOnThisLine =

; }

hasEmittedTokensOnThisLine()

{

EmittedTokensOnThisLine; }

setEmittedDirectiveOnThisLine() { EmittedDirectiveOnThisLine =

; }

hasEmittedDirectiveOnThisLine()

{

EmittedDirectiveOnThisLine;

startNewLineIfNeeded();

PrevFID)

;

StringRef RelativePath,

*SuggestedModule,

PragmaMessageKind Kind, StringRef Str)

;

HandleWhitespaceBeforeTok(

&Tok,

RequireSpace,

RequireSameLine);

MoveToLine(

&Tok,

RequireStartOfLine) {

TargetLine = PLoc.

() ? PLoc.

() : CurLine;

MoveToLine(TargetLine, RequireStartOfLine) || IsFirstInFile;

TargetLine = PLoc.

() ? PLoc.

() : CurLine;

MoveToLine(TargetLine, RequireStartOfLine);

MoveToLine(

LineNo,

RequireStartOfLine);

AvoidConcat(

&PrevPrevTok,

&PrevTok,

ConcatInfo.

(PrevPrevTok, PrevTok, Tok);

WriteLineInfo(

LineNo,

*Extra=

,

ExtraLen=0);

LineMarkersAreDisabled()

{

DisableLineMarkers; }

HandleNewlinesInToken(

*TokStr,

Len);

BeginModule(

*M);

EndModule(

*M);

GetNumToksToSkip()

{

NumToksToSkip; }

ResetSkipToks() { NumToksToSkip = 0; }

PrintPPOutputPPCallbacks::WriteLineInfo(

LineNo,

startNewLineIfNeeded();

(UseLineDirectives) {

*OS <<

<<

<< LineNo <<

<<

;

OS->write_escaped(CurFilename);

*OS <<

<<

<< LineNo <<

<<

;

OS->write_escaped(CurFilename);

OS->write(Extra, ExtraLen);

OS->write(

, 2);

OS->write(

, 4);

PrintPPOutputPPCallbacks::MoveToLine(

LineNo,

RequireStartOfLine) {

StartedNewLine =

;

((RequireStartOfLine && EmittedTokensOnThisLine) ||

EmittedDirectiveOnThisLine) {

StartedNewLine =

;

EmittedTokensOnThisLine =

;

EmittedDirectiveOnThisLine =

;

(CurLine == LineNo) {

}

(MinimizeWhitespace && DisableLineMarkers) {

}

(!StartedNewLine && LineNo - CurLine == 1) {

StartedNewLine =

;

}

(!DisableLineMarkers) {

(LineNo - CurLine <= 8) {

*NewLines =

;

OS->write(NewLines, LineNo - CurLine);

WriteLineInfo(LineNo,

, 0);

StartedNewLine =

;

}

(EmittedTokensOnThisLine) {

StartedNewLine =

;

(StartedNewLine) {

EmittedTokensOnThisLine =

;

EmittedDirectiveOnThisLine =

;

StartedNewLine;

PrintPPOutputPPCallbacks::startNewLineIfNeeded() {

(EmittedTokensOnThisLine || EmittedDirectiveOnThisLine) {

EmittedTokensOnThisLine =

;

EmittedDirectiveOnThisLine =

;

FileChangeReason Reason,

MoveToLine(IncludeLoc,

);

(DisableLineMarkers) {

(!MinimizeWhitespace)

startNewLineIfNeeded();

WriteLineInfo(CurLine);

IsFirstFileEntered =

;

WriteLineInfo(CurLine,

, 2);

WriteLineInfo(CurLine,

, 2);

WriteLineInfo(CurLine);

PrintPPOutputPPCallbacks::EmbedDirective(

(!DumpEmbedDirectives)

MoveToLine(HashLoc,

);

*OS <<

<< (IsAngled ?

:

) <<

<< (IsAngled ?

:

);

(

&

: Toks) {

(

.hasLeadingSpace())

SkipAnnotToks =

;

*OS <<

;

SkipAnnotToks =

;

*OS <<

;

setEmittedDirectiveOnThisLine();

PrintPPOutputPPCallbacks::InclusionDirective(

StringRef SearchPath, StringRef RelativePath,

*SuggestedModule,

(DumpIncludeDirectives || (KeepSystemIncludes &&

(

))) {

MoveToLine(HashLoc,

);

std::string TokenText = PP.

(IncludeTok);

assert(!TokenText.empty());

*OS <<

<< TokenText <<

<< (IsAngled ?

:

) <<

<< (IsAngled ?

:

)

<< (DumpIncludeDirectives ?

:

)

setEmittedDirectiveOnThisLine();

(ModuleImported) {

tok::pp_include:

tok::pp_include_next:

MoveToLine(HashLoc,

);

*OS <<

<<

<< (IsAngled ?

:

) <<

<< (IsAngled ?

:

)

setEmittedDirectiveOnThisLine();

tok::pp___include_macros:

llvm_unreachable(

);

PrintPPOutputPPCallbacks::BeginModule(

*M) {

startNewLineIfNeeded();

setEmittedDirectiveOnThisLine();

PrintPPOutputPPCallbacks::EndModule(

*M) {

startNewLineIfNeeded();

setEmittedDirectiveOnThisLine();

MoveToLine(

,

);

OS->write(

, strlen(

));

OS->write(S.begin(), S.size());

setEmittedTokensOnThisLine();

PrintPPOutputPPCallbacks::MacroDefined(

&MacroNameTok,

((!DumpDefines && !DirectivesOnly) ||

(DirectivesOnly && !MI->

()) {

(

.isWrittenInBuiltinFile(DefLoc) ||

.isWrittenInCommandLineFile(DefLoc))

MoveToLine(DefLoc,

);

setEmittedDirectiveOnThisLine();

PrintPPOutputPPCallbacks::MacroUndefined(

&MacroNameTok,

(!DumpDefines && !DirectivesOnly)

setEmittedDirectiveOnThisLine();

(

Char : Str) {

(

(Char) && Char !=

&& Char !=

)

<< (char)(

+ ((Char >> 6) & 7))

<< (char)(

+ ((Char >> 3) & 7))

<< (char)(

+ ((Char >> 0) & 7));

PragmaMessageKind Kind,

MoveToLine(

,

);

*OS <<

;

*OS <<

;

(Kind == PMK_Message)

setEmittedDirectiveOnThisLine();

StringRef DebugType) {

MoveToLine(

,

);

*OS <<

;

setEmittedDirectiveOnThisLine();

PrintPPOutputPPCallbacks::

MoveToLine(

,

);

*OS <<

<<

<<

;

setEmittedDirectiveOnThisLine();

PrintPPOutputPPCallbacks::

MoveToLine(

,

);

*OS <<

<<

<<

;

setEmittedDirectiveOnThisLine();

MoveToLine(

,

);

*OS <<

<<

<<

;

diag::Severity::Remark:

diag::Severity::Warning:

diag::Severity::Error:

diag::Severity::Ignored:

diag::Severity::Fatal:

*OS <<

<< Str <<

;

setEmittedDirectiveOnThisLine();

PragmaWarningSpecifier WarningSpec,

MoveToLine(

,

);

*OS <<

;

(WarningSpec) {

PWS_Default: *OS <<

;

;

PWS_Disable: *OS <<

;

;

PWS_Error: *OS <<

;

;

PWS_Once: *OS <<

;

;

PWS_Suppress: *OS <<

;

;

PWS_Level1: *OS <<

;

;

PWS_Level2: *OS <<

;

;

PWS_Level3: *OS <<

;

;

PWS_Level4: *OS <<

;

;

setEmittedDirectiveOnThisLine();

MoveToLine(

,

);

*OS <<

;

*OS <<

<<

;

setEmittedDirectiveOnThisLine();

MoveToLine(

,

);

*OS <<

;

setEmittedDirectiveOnThisLine();

MoveToLine(

,

);

*OS <<

;

setEmittedDirectiveOnThisLine();

MoveToLine(

,

);

*OS <<

;

setEmittedDirectiveOnThisLine();

PrintPPOutputPPCallbacks::

MoveToLine(

,

);

*OS <<

;

setEmittedDirectiveOnThisLine();

PrintPPOutputPPCallbacks::

MoveToLine(

,

);

*OS <<

;

setEmittedDirectiveOnThisLine();

PrintPPOutputPPCallbacks::HandleWhitespaceBeforeTok(

&Tok,

RequireSameLine) {

(Tok.

(tok::eof) ||

!Tok.

(tok::annot_module_begin) && !Tok.

(tok::annot_module_end) &&

!Tok.

(tok::annot_repl_input_end) && !Tok.

(tok::annot_embed)))

((!RequireSameLine || EmittedDirectiveOnThisLine) &&

MoveToLine(Tok,

EmittedDirectiveOnThisLine)) {

(MinimizeWhitespace) {

(Tok.

(tok::hash))

ColNo =

.getExpansionColumnNumber(Tok.

());

(ColNo <= 1 && Tok.

(tok::hash))

(; ColNo > 1; --ColNo)

(RequireSpace || (!MinimizeWhitespace && Tok.

()) ||

((EmittedTokensOnThisLine || EmittedDirectiveOnThisLine) &&

AvoidConcat(PrevPrevTok, PrevTok, Tok)))

PrevPrevTok = PrevTok;

PrintPPOutputPPCallbacks::HandleNewlinesInToken(

*TokStr,

NumNewlines = 0;

(; Len; --Len, ++TokStr) {

(*TokStr !=

&&

(TokStr[1] ==

|| TokStr[1] ==

) &&

TokStr[0] != TokStr[1]) {

(NumNewlines == 0)

;

CurLine += NumNewlines;

PrintPPOutputPPCallbacks *Callbacks;

ShouldExpandTokens;

UnknownPragmaHandler(

*prefix, PrintPPOutputPPCallbacks *callbacks,

RequireTokenExpansion)

: Prefix(prefix), Callbacks(callbacks),

ShouldExpandTokens(RequireTokenExpansion) {}

&PragmaTok)

{

Callbacks->MoveToLine(PragmaTok.

(),

);

Callbacks->OS->write(Prefix, strlen(Prefix));

Callbacks->setEmittedTokensOnThisLine();

(ShouldExpandTokens) {

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

PP.EnterTokenStream(std::move(Toks),

1,

IsFirst =

;

(PragmaTok.

(tok::eod)) {

Callbacks->HandleWhitespaceBeforeTok(PragmaTok,

IsFirst,

std::string TokSpell = PP.

(PragmaTok);

Callbacks->OS->write(&TokSpell[0], TokSpell.size());

Callbacks->setEmittedTokensOnThisLine();

(ShouldExpandTokens)

Callbacks->setEmittedDirectiveOnThisLine();

PrintPPOutputPPCallbacks *Callbacks) {

DropComments = PP.

().TraditionalCPP &&

IsStartOfLine =

;

Callbacks->HandleWhitespaceBeforeTok(Tok,

,

(DropComments && Tok.

(tok::comment)) {

}

(Tok.

(tok::annot_repl_input_end)) {

}

(Tok.

(tok::eod)) {

IsStartOfLine =

;

}

(Tok.

(tok::annot_module_include)) {

IsStartOfLine =

;

}

(Tok.

(tok::annot_module_begin)) {

Callbacks->BeginModule(

IsStartOfLine =

;

}

(Tok.

(tok::annot_module_end)) {

Callbacks->EndModule(

IsStartOfLine =

;

}

(Tok.

(tok::annot_header_unit)) {

*Callbacks->OS <<

;

Callbacks->OS->write_escaped(Name);

*Callbacks->OS <<

;

}

(Tok.

(tok::annot_embed)) {

assert(Callbacks->expandEmbedContents() &&

);

PrintComma =

;

(

=

->BinaryData.begin(), End =

->BinaryData.end();

*Callbacks->OS <<

;

*Callbacks->OS <<

(*Iter);

*Callbacks->OS << II->getName();

}

(Tok.

() < std::size(Buffer)) {

*TokPtr = Buffer;

Callbacks->OS->write(TokPtr, Len);

(Tok.

() == tok::comment || Tok.

() == tok::unknown)

Callbacks->HandleNewlinesInToken(TokPtr, Len);

(Tok.

(tok::comment) && Len >= 2 && TokPtr[0] ==

&&

TokPtr[1] ==

) {

Callbacks->setEmittedDirectiveOnThisLine();

Callbacks->OS->write(S.data(), S.size());

(Tok.

() == tok::comment || Tok.

() == tok::unknown)

Callbacks->HandleNewlinesInToken(S.data(), S.size());

(Tok.

(tok::comment) && S.size() >= 2 && S[0] ==

&& S[1] ==

) {

Callbacks->setEmittedDirectiveOnThisLine();

Callbacks->setEmittedTokensOnThisLine();

IsStartOfLine =

;

(Tok.

(tok::eof) || Tok.

(tok::annot_repl_input_end))

(

I = 0,

= Callbacks->GetNumToksToSkip(); I <

; ++I)

Callbacks->ResetSkipToks();

LHS->first->getName().compare(RHS->first->getName());

*MD = I->second.getLatest();

(MD && MD->isDefined())

llvm::array_pod_sort(MacrosByID.begin(), MacrosByID.end(),

);

(

i = 0, e = MacrosByID.size(); i != e; ++i) {

assert(Opts.

&&

);

PrintPPOutputPPCallbacks *Callbacks =

PrintPPOutputPPCallbacks(

std::unique_ptr<UnknownPragmaHandler> MicrosoftExtHandler(

UnknownPragmaHandler(

, Callbacks,

std::unique_ptr<UnknownPragmaHandler> GCCHandler(

UnknownPragmaHandler(

, Callbacks,

std::unique_ptr<UnknownPragmaHandler> ClangHandler(

UnknownPragmaHandler(

, Callbacks,

std::unique_ptr<UnknownPragmaHandler> OpenMPHandler(

UnknownPragmaHandler(

, Callbacks,

Defines the Diagnostic-related interfaces.

llvm::MachO::FileType FileType

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

Defines the PPCallbacks interface.

Defines the clang::Preprocessor interface.

std::pair< const IdentifierInfo *, MacroInfo * > id_macro_pair

static void DoPrintMacros(Preprocessor &PP, raw_ostream *OS)

static void PrintMacroDefinition(const IdentifierInfo &II, const MacroInfo &MI, Preprocessor &PP, raw_ostream *OS)

PrintMacroDefinition - Print a macro definition in a form that will be properly accepted back as a de...

static int MacroIDCompare(const id_macro_pair *LHS, const id_macro_pair *RHS)

static void PrintPreprocessedTokens(Preprocessor &PP, Token &Tok, PrintPPOutputPPCallbacks *Callbacks)

static void outputPrintable(raw_ostream *OS, StringRef Str)

Defines the SourceManager interface.

Represents a character-granular source range.

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

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

tok::PPKeywordKind getPPKeywordID() const

Return the preprocessor keyword ID for this identifier.

StringRef getName() const

Return the actual identifier string.

Record the location of an inclusion directive, such as an #include or #import statement.

A description of the current definition of a macro.

MacroInfo * getMacroInfo() const

Get the MacroInfo that should be used for this definition.

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

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

bool isFunctionLike() const

const_tokens_iterator tokens_begin() const

param_iterator param_begin() const

bool isBuiltinMacro() const

Return true if this macro requires processing before expansion.

IdentifierInfo *const * param_iterator

Parameters - The list of parameters for a function-like macro.

SourceLocation getDefinitionLoc() const

Return the location that the macro was defined at.

bool tokens_empty() const

param_iterator param_end() const

ArrayRef< Token > tokens() const

bool isGNUVarargs() const

Describes a module or submodule.

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 FileChanged(SourceLocation Loc, FileChangeReason Reason, SrcMgr::CharacteristicKind FileType, FileID PrevFID=FileID())

Callback invoked whenever a source file is entered or exited.

virtual void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD, const MacroDirective *Undef)

Hook called whenever a macro #undef is seen.

virtual void MacroDefined(const Token &MacroNameTok, const MacroDirective *MD)

Hook called whenever a macro definition is seen.

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

Callback invoked when a #pragma gcc diagnostic 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 EmbedDirective(SourceLocation HashLoc, StringRef FileName, bool IsAngled, OptionalFileEntryRef File, const LexEmbedParametersResult &Params)

Callback invoked whenever an embed directive has been processed, regardless of whether the embed will...

virtual void Ident(SourceLocation Loc, StringRef str)

Callback invoked when a #ident or #sccs 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.

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

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

PreprocessorOutputOptions - Options for controlling the C preprocessor output (e.g....

unsigned UseLineDirectives

Use #line instead of GCC-style # N.

unsigned ShowMacros

Print macro definitions.

unsigned ShowIncludeDirectives

Print includes, imports etc. within preprocessed output.

unsigned ShowMacroComments

Show comments, even in macros.

unsigned ShowCPP

Print normal preprocessed output.

unsigned MinimizeWhitespace

Ignore whitespace from input.

unsigned KeepSystemIncludes

Do not expand system headers.

unsigned ShowComments

Show comments.

unsigned ShowEmbedDirectives

Print embeds, etc. within preprocessed.

unsigned ShowLineMarkers

Show #line markers.

unsigned DirectivesOnly

Process directives but do not expand macros.

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

void IgnorePragmas()

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

macro_iterator macro_begin(bool IncludeExternalMacros=true) const

void Lex(Token &Result)

Lex the next token for this preprocessor.

void addPPCallbacks(std::unique_ptr< PPCallbacks > C)

void EnterMainSourceFile()

Enter the specified FileID as the main source file, which implicitly adds the builtin defines etc.

macro_iterator macro_end(bool IncludeExternalMacros=true) const

SourceManager & getSourceManager() const

bool getCommentRetentionState() const

void SetMacroExpansionOnlyInDirectives()

Disables macro expansion everywhere except for preprocessor directives.

MacroMap::const_iterator macro_iterator

void LexUnexpandedToken(Token &Result)

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

void AddPragmaHandler(StringRef Namespace, PragmaHandler *Handler)

Add the specified pragma handler to this preprocessor.

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

const LangOptions & getLangOpts() const

void LexTokensUntilEOF(std::vector< Token > *Tokens=nullptr)

Lex all tokens for this preprocessor until (and excluding) end of file.

void SetCommentRetentionState(bool KeepComments, bool KeepMacroComments)

Control whether the preprocessor retains comments in output.

void RemovePragmaHandler(StringRef Namespace, PragmaHandler *Handler)

Remove the specific pragma handler from this preprocessor.

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.

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.

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

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

Returns the "presumed" location of a SourceLocation specifies.

TokenConcatenation class, which answers the question of "Is it safe to emit two tokens without a whit...

bool AvoidConcat(const Token &PrevPrevTok, const Token &PrevTok, const Token &Tok) const

AvoidConcat - If printing PrevTok immediately followed by Tok would cause the two individual tokens t...

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

IdentifierInfo * getIdentifierInfo() const

bool isLiteral() const

Return true if this is a "literal", like a numeric constant, string, etc.

SourceLocation getLocation() const

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

unsigned getLength() const

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

void * getAnnotationValue() const

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.

bool isNot(tok::TokenKind K) const

bool isAnnotation() const

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

void startToken()

Reset all flags to cleared.

bool needsCleaning() const

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

const char * getLiteralData() const

getLiteralData - For a literal token (numeric constant, string, etc), this returns a pointer to the s...

CharacteristicKind

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

bool isSystem(CharacteristicKind CK)

Determine whether a file / directory characteristic is for system code.

Severity

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

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

void DoPrintPreprocessedInput(Preprocessor &PP, raw_ostream *OS, const PreprocessorOutputOptions &Opts)

DoPrintPreprocessedInput - Implement -E mode.

const FunctionProtoType * T

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

std::optional< PPEmbedParameterIfEmpty > MaybeIfEmptyParam

std::optional< PPEmbedParameterOffset > MaybeOffsetParam

std::optional< PPEmbedParameterLimit > MaybeLimitParam

std::optional< PPEmbedParameterSuffix > MaybeSuffixParam

std::optional< PPEmbedParameterPrefix > MaybePrefixParam

Describes how and where the pragma was introduced.

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