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

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

clang: lib/Lex/TokenLexer.cpp Source File

;

NextTokGetsSpace =

;

DisableMacroExpansion =

;

MacroStartSLocOffset =

.getNextLocalOffset();

assert(Tokens[0].getLocation().isValid());

assert((Tokens[0].getLocation().isFileID() || Tokens[0].is(tok::comment)) &&

);

assert(ExpandLocStart.

());

MacroDefStart =

.getExpansionLoc(Tokens[0].getLocation());

MacroExpansionStart =

.createExpansionLoc(MacroDefStart,

ExpandFunctionArguments();

disableMacroExpansion,

ownsTokens,

assert(!isReinject || disableMacroExpansion);

ActualArgs =

;

OwnsTokens = ownsTokens;

DisableMacroExpansion = disableMacroExpansion;

IsReinject = isReinject;

AtStartOfLine =

;

HasLeadingSpace =

;

NextTokGetsSpace =

;

TokenLexer::destroy() {

(ActualArgs) ActualArgs->

(PP);

TokenLexer::MaybeRemoveCommaBeforeVaArgs(

(!

->isVariadic() || MacroArgNo !=

->getNumParams()-1)

(!HasPasteOperator && !PP.

().MSVCCompat)

&&

->getNumParams() < 2)

(ResultToks.empty() || !ResultToks.back().is(tok::comma))

(HasPasteOperator)

PP.

(ResultToks.back().getLocation(), diag::ext_paste_comma);

ResultToks.pop_back();

(!ResultToks.empty()) {

(ResultToks.back().is(tok::hashhash))

ResultToks.pop_back();

NextTokGetsSpace =

;

TokenLexer::stringifyVAOPTContents(

NumVAOptTokens = ResultToks.size() - NumToksPriorToVAOpt;

*

VAOPTTokens =

NumVAOptTokens ? &ResultToks[NumToksPriorToVAOpt] :

;

(

CurTokenIdx = 0; CurTokenIdx != NumVAOptTokens;

(VAOPTTokens[CurTokenIdx].is(tok::hashhash)) {

assert(CurTokenIdx != 0 &&

);

&LHS = VAOPTTokens[CurTokenIdx - 1];

ConcatenatedVAOPTResultToks.back() = LHS;

(CurTokenIdx == NumVAOptTokens)

ConcatenatedVAOPTResultToks.push_back(VAOPTTokens[CurTokenIdx]);

ConcatenatedVAOPTResultToks.push_back(VCtx.

());

getExpansionLocForMacroDefLoc(VCtx.

());

getExpansionLocForMacroDefLoc(VAOPTClosingParenLoc);

ExpansionLocStartWithinMacro, ExpansionLocEndWithinMacro);

ResultToks.resize(NumToksPriorToVAOpt + 1);

ResultToks.back() = StringifiedVAOPT;

TokenLexer::ExpandFunctionArguments() {

MadeChange =

;

std::optional<bool> CalledWithVariadicArguments;

(

I = 0,

= NumTokens; I !=

; ++I) {

&CurTok = Tokens[I];

(I != 0 && !Tokens[I-1].is(tok::hashhash) && CurTok.

())

NextTokGetsSpace =

;

assert(Tokens[I + 1].is(tok::l_paren) &&

);

(Tokens[I].is(tok::l_paren))

(!CalledWithVariadicArguments) {

CalledWithVariadicArguments =

(!*CalledWithVariadicArguments) {

stringifyVAOPTContents(ResultToks, VCtx,

Tokens[I].getLocation());

(ResultToks.size() && ResultToks.back().is(tok::hashhash)) {

ResultToks.pop_back();

}

((I + 1 !=

) && Tokens[I + 1].is(tok::hashhash)) {

);

ResultToks.erase(ResultToks.begin() +

Tokens[I + 1].is(tok::hashhash)) {

(CurTok.

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

ArgNo =

->getParameterNum(Tokens[I+1].getIdentifierInfo());

assert((ArgNo != -1 || VCtx.

(Tokens[I + 1])) &&

);

CurTok.

(tok::hashat));

getExpansionLocForMacroDefLoc(CurTok.

());

getExpansionLocForMacroDefLoc(Tokens[I+1].getLocation());

Charify = CurTok.

(tok::hashat);

UnexpArg, PP, Charify, ExpansionLocStart, ExpansionLocEnd);

(NextTokGetsSpace)

ResultToks.push_back(Res);

NextTokGetsSpace =

;

NonEmptyPasteBefore =

!ResultToks.empty() && ResultToks.back().is(tok::hashhash);

PasteBefore = I != 0 && Tokens[I-1].

(tok::hashhash);

PasteAfter = I+1 !=

&& Tokens[I+1].

(tok::hashhash);

RParenAfter = I+1 !=

&& Tokens[I+1].

(tok::r_paren);

assert((!NonEmptyPasteBefore || PasteBefore || VCtx.

()) &&

);

ArgNo = II ?

->getParameterNum(II) : -1;

ResultToks.push_back(CurTok);

(NextTokGetsSpace) {

NextTokGetsSpace =

;

}

(PasteBefore && !NonEmptyPasteBefore)

MaybeRemoveCommaBeforeVaArgs(ResultToks,

(!PasteBefore && !PasteAfter) {

*ResultArgToks;

ResultArgToks = ArgTok;

(ResultArgToks->

(tok::eof)) {

FirstResult = ResultToks.size();

ResultToks.append(ResultArgToks, ResultArgToks+NumToks);

(PP.

().MSVCCompat && NumToks == 1 &&

ResultToks.back().is(tok::comma))

(

&Tok : llvm::drop_begin(ResultToks, FirstResult))

(Tok.is(tok::hashhash))

Tok.setKind(tok::unknown);

(ExpandLocStart.

()) {

ResultToks.begin()+FirstResult,

NextTokGetsSpace =

;

(NonEmptyPasteBefore) {

assert(VCtx.

() &&

);

}

(RParenAfter)

VaArgsPseudoPaste =

;

(NonEmptyPasteBefore && ResultToks.size() >= 2 &&

ResultToks[ResultToks.size()-2].is(tok::comma) &&

(

)ArgNo ==

->getNumParams()-1 &&

->isVariadic()) {

VaArgsPseudoPaste =

;

PP.

(ResultToks.pop_back_val().getLocation(), diag::ext_paste_comma);

ResultToks.append(ArgToks, ArgToks+NumToks);

(

&Tok : llvm::make_range(ResultToks.end() - NumToks,

(Tok.is(tok::hashhash))

Tok.setKind(tok::unknown);

(ExpandLocStart.

()) {

ResultToks.end()-NumToks, ResultToks.end());

(!VaArgsPseudoPaste) {

ResultToks[ResultToks.size() - NumToks].setFlagValue(

NextTokGetsSpace =

;

(RParenAfter && !NonEmptyPasteBefore)

(NonEmptyPasteBefore) {

assert(ResultToks.back().is(tok::hashhash));

ResultToks.pop_back();

MaybeRemoveCommaBeforeVaArgs(ResultToks,

assert(!OwnsTokens &&

);

NumTokens = ResultToks.size();

Tokens = PP.cacheMacroExpandedTokens(

, ResultToks);

&SecondTok) {

FirstTok.

(tok::identifier) &&

(Macro) Macro->EnableMacro();

(CurTokenIdx == 0)

isFirstToken = CurTokenIdx == 0;

Tok = Tokens[CurTokenIdx++];

TokenIsFromPaste =

;

(!isAtEnd() && Macro &&

(Tokens[CurTokenIdx].is(tok::hashhash) ||

(pasteTokens(Tok))

TokenIsFromPaste =

;

(ExpandLocStart.

() &&

.isBeforeInSLocAddrSpace(Tok.

(), MacroStartSLocOffset)) {

(Tok.

(tok::comment)) {

instLoc = getExpansionLocForMacroDefLoc(Tok.

());

AtStartOfLine =

;

HasLeadingSpace =

;

TokenLexer::pasteTokens(

&Tok) {

pasteTokens(Tok,

(Tokens, NumTokens), CurTokenIdx);

&CurIdx) {

assert(CurIdx > 0 &&

);

assert((TokenStream[CurIdx].is(tok::hashhash) ||

);

(PP.

().MicrosoftExt && (CurIdx >= 2) &&

TokenStream[CurIdx - 2].is(tok::hashhash))

*ResultTokStrPtr =

;

IsAtEnd = [&TokenStream, &CurIdx] {

TokenStream.size() == CurIdx;

PasteOpLoc = TokenStream[CurIdx].getLocation();

(TokenStream[CurIdx].is(tok::hashhash))

assert(!IsAtEnd() &&

);

&RHS = TokenStream[CurIdx];

*BufPtr = &Buffer[0];

(BufPtr != &Buffer[0])

(&Buffer[0], BufPtr, LHSLen);

BufPtr = Buffer.data() + LHSLen;

(RHSLen && BufPtr != &Buffer[LHSLen])

(&Buffer[LHSLen], BufPtr, RHSLen);

Buffer.resize(LHSLen+RHSLen);

ResultTokTmp.

(tok::string_literal);

.setKind(tok::raw_identifier);

.setRawIdentifierData(ResultTokStrPtr);

.setLocation(ResultTokLoc);

.setLength(LHSLen+RHSLen);

);

*ScratchBufStart

ResultTokStrPtr, ResultTokStrPtr+LHSLen+RHSLen);

.createExpansionLoc(PasteOpLoc, ExpandLocStart, ExpandLocEnd, 2);

(PP.

().MicrosoftExt && LHSTok.

(tok::slash) &&

RHS.

(tok::slash)) {

HandleMicrosoftCommentPaste(LHSTok,

);

: diag::err_pp_bad_paste)

(

.is(tok::hashhash))

.setKind(tok::unknown);

}

(!IsAtEnd() && TokenStream[CurIdx].is(tok::hashhash));

StartLoc = getExpansionLocForMacroDefLoc(StartLoc);

EndLoc = getExpansionLocForMacroDefLoc(EndLoc);

MacroFID =

.getFileID(MacroExpansionStart);

(

.getFileID(StartLoc) != MacroFID)

StartLoc =

.getImmediateExpansionRange(StartLoc).getBegin();

(

.getFileID(EndLoc) != MacroFID)

EndLoc =

.getImmediateExpansionRange(EndLoc).getEnd();

(LHSTok.

(tok::raw_identifier)) {

Tokens[CurTokenIdx].

(tok::l_paren);

Tokens[NumTokens-1].

(tok::eod) && !isAtEnd();

PP.

(OpLoc, diag::ext_comment_paste_microsoft);

assert(Macro &&

);

Macro->EnableMacro();

TokenLexer::getExpansionLocForMacroDefLoc(

loc)

{

assert(ExpandLocStart.

() && MacroExpansionStart.

() &&

);

assert(

.isInSLocAddrSpace(loc, MacroDefStart, MacroDefLength) &&

);

.isInSLocAddrSpace(loc, MacroDefStart, MacroDefLength, &relativeOffset);

*&begin_tokens,

* end_tokens) {

assert(begin_tokens + 1 < end_tokens);

Distance <= MaxDistance;

Partition =

.take_while([&](

&

) {

.getLocation().isFileID() && NearLast(

.getLocation());

BeginFID =

.getFileID(BeginLoc);

.getComposedLoc(BeginFID,

.getFileIDSize(BeginFID));

Partition =

.take_while([&](

&

) {

.getLocation() >= BeginLoc &&

.getLocation() <= Limit

&& NearLast(

.getLocation());

assert(!Partition.empty());

Partition.back().getEndLoc().getRawEncoding() -

Partition.front().getLocation().getRawEncoding();

.createMacroArgExpansionLoc(BeginLoc, ExpandLoc, FullLength);

assert(llvm::all_of(Partition.drop_front(),

[&

, ID =

.getFileID(Partition.front().getLocation())](

return ID == SM.getFileID(T.getLocation());

);

(

&

: Partition) {

begin_tokens = &Partition.back() + 1;

TokenLexer::updateLocForMacroArgTokens(

ArgIdSpellLoc,

*begin_tokens,

*end_tokens) {

getExpansionLocForMacroDefLoc(ArgIdSpellLoc);

(begin_tokens < end_tokens) {

(end_tokens - begin_tokens == 1) {

&Tok = *begin_tokens;

TokenLexer::PropagateLineStartLeadingSpaceInfo(

&

) {

AtStartOfLine =

.isAtStartOfLine();

HasLeadingSpace =

.hasLeadingSpace();

Defines the Diagnostic-related interfaces.

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::Preprocessor interface.

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.

static bool isWideStringLiteralFromMacro(const Token &FirstTok, const Token &SecondTok)

Checks if two tokens form wide string literal.

static void updateConsecutiveMacroArgTokens(SourceManager &SM, SourceLocation ExpandLoc, Token *&begin_tokens, Token *end_tokens)

Finds the tokens that are consecutive (from the same FileID) creates a single SLocEntry,...

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

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.

bool isHandleIdentifierCase() const

Return true if the Preprocessor::HandleIdentifier must be called on a token of this identifier.

tok::TokenKind getTokenID() const

If this is a source-language token (e.g.

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.

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

MacroArgs - An instance of this class captures information about the formal arguments specified to a ...

const Token * getUnexpArgument(unsigned Arg) const

getUnexpArgument - Return a pointer to the first token of the unexpanded token list for the specified...

const std::vector< Token > & getPreExpArgument(unsigned Arg, Preprocessor &PP)

getPreExpArgument - Return the pre-expanded form of the specified argument.

static unsigned getArgLength(const Token *ArgPtr)

getArgLength - Given a pointer to an expanded or unexpanded argument, return the number of tokens,...

bool ArgNeedsPreexpansion(const Token *ArgTok, Preprocessor &PP) const

ArgNeedsPreexpansion - If we can prove that the argument won't be affected by pre-expansion,...

bool invokedWithVariadicArgument(const MacroInfo *const MI, Preprocessor &PP)

Returns true if the macro was defined with a variadic (ellipsis) parameter AND was invoked with at le...

bool isVarargsElidedUse() const

isVarargsElidedUse - Return true if this is a C99 style varargs macro invocation and there was no arg...

static Token StringifyArgument(const Token *ArgToks, Preprocessor &PP, bool Charify, SourceLocation ExpansionLocStart, SourceLocation ExpansionLocEnd)

StringifyArgument - Implement C99 6.10.3.2p2, converting a sequence of tokens into the literal string...

void destroy(Preprocessor &PP)

destroy - Destroy and deallocate the memory for this object.

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

bool isFunctionLike() const

const_tokens_iterator tokens_begin() const

const_tokens_iterator tokens_end() const

unsigned getNumParams() const

unsigned getDefinitionLength(const SourceManager &SM) const

Get length in characters of the macro definition.

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

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

IdentifierInfo * LookUpIdentifierInfo(Token &Identifier) const

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

bool HandleEndOfTokenLexer(Token &Result)

Callback invoked when the current TokenLexer hits the end of its token stream.

void HandlePoisonedIdentifier(Token &Identifier)

Display reason for poisoned identifier.

bool HandleIdentifier(Token &Identifier)

Callback invoked when the lexer reads an identifier and has filled in the tokens IdentifierInfo membe...

void IncrementPasteCounter(bool isFast)

Increment the counters for the number of token paste operations performed.

SourceManager & getSourceManager() const

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

DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const

Forwarding function for diagnostics.

void HandleMicrosoftCommentPaste(Token &Tok)

When the macro expander pastes together a comment (/##/) in Microsoft mode, this method handles updat...

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.

UIntTy getRawEncoding() const

When a SourceLocation itself cannot be used, this returns an (opaque) 32-bit integer encoding for it.

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

FileID getFileID(SourceLocation SpellingLoc) const

Return the FileID for a SourceLocation.

StringRef getBufferData(FileID FID, bool *Invalid=nullptr) const

Return a StringRef to the source buffer data for the specified FileID.

SourceLocation getLocForStartOfFile(FileID FID) const

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

bool isParsingPreprocessorDirective() const

isParsingPreprocessorDirective - Return true if we are in the middle of a preprocessor directive.

unsigned isNextTokenLParen() const

If the next token lexed will pop this macro off the expansion stack, return 2.

bool Lex(Token &Tok)

Lex and return a token from this macro stream.

void Init(Token &Tok, SourceLocation ELEnd, MacroInfo *MI, MacroArgs *Actuals)

Initialize this TokenLexer to expand from the specified macro with the specified argument information...

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

IdentifierInfo * getIdentifierInfo() const

bool isAnyIdentifier() const

Return true if this is a raw identifier (when lexing in raw mode) or a non-keyword identifier (when l...

void clearFlag(TokenFlags Flag)

Unset the specified flag.

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

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

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

bool isAnnotation() const

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

bool stringifiedInMacro() const

Returns true if this token is formed by macro by stringizing or charizing operator.

void startToken()

Reset all flags to cleared.

void setFlagValue(TokenFlags Flag, bool Val)

Set a flag to either true or false.

const char * getLiteralData() const

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

void setFlag(TokenFlags Flag)

Set the specified flag.

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

void hasPlaceholderAfterHashhashAtStart()

bool isInVAOpt() const

Returns true if we have seen the VA_OPT and '(' but before having seen the matching ')'.

bool isVAOptToken(const Token &T) const

void sawHashOrHashAtBefore(const bool HasLeadingSpace, const bool IsHashAt)

SourceLocation getVAOptLoc() const

unsigned int getNumberOfTokensPriorToVAOpt() const

bool getLeadingSpaceForStringifiedToken() const

bool hasStringifyOrCharifyBefore() const

bool hasCharifyBefore() const

void sawOpeningParen(SourceLocation LParenLoc)

Call this function each time an lparen is seen.

void hasPlaceholderBeforeRParen()

const Token & getEOFTok() const

bool sawClosingParen()

Call this function each time an rparen is seen.

bool beginsWithPlaceholder() const

bool endsWithPlaceholder() const

void sawVAOptFollowedByOpeningParens(const SourceLocation VAOptLoc, const unsigned int NumPriorTokens)

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

@ Result

The result type of a method or function.

const FunctionProtoType * T

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