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

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

clang: lib/ASTMatchers/Dynamic/Parser.cpp Source File

ast_matchers {

: Code(MatcherCode), StartOfLine(MatcherCode), Error(Error) {

NextToken = getNextToken();

CodeCompletionOffset)

: Code(MatcherCode), StartOfLine(MatcherCode), Error(Error),

CodeCompletionLocation(MatcherCode.data() + CodeCompletionOffset) {

NextToken = getNextToken();

NextToken = getNextToken();

NextToken = getNextToken();

.Range.Start = currentLocation();

(CodeCompletionLocation && CodeCompletionLocation <= Code.data()) {

.Text = StringRef(CodeCompletionLocation, 0);

CodeCompletionLocation =

;

Code = Code.drop_until([](

) {

==

; });

getNextToken();

.Text = Code.substr(0, 1);

Code = Code.drop_front();

.Text = Code.substr(0, 1);

Code = Code.drop_front();

StartOfLine = Code.drop_front();

.Text = Code.substr(0, 1);

Code = Code.drop_front();

.Text = Code.substr(0, 1);

Code = Code.drop_front();

.Text = Code.substr(0, 1);

Code = Code.drop_front();

consumeStringLiteral(&

);

:

:

:

:

:

:

:

:

:

:

consumeNumberLiteral(&

);

TokenLength = 1;

(CodeCompletionLocation == Code.data() + TokenLength) {

CodeCompletionLocation =

;

.Text = Code.substr(0, TokenLength);

Code = Code.drop_front(TokenLength);

(TokenLength == Code.size() || !

(Code[TokenLength]))

(TokenLength == 4 && Code.starts_with(

)) {

}

(TokenLength == 5 && Code.starts_with(

)) {

.Text = Code.substr(0, TokenLength);

Code = Code.drop_front(TokenLength);

.Text = Code.substr(0, 1);

Code = Code.drop_front(1);

.Range.End = currentLocation();

consumeNumberLiteral(TokenInfo *

) {

isFloatingLiteral =

;

(Code.size() > 1) {

:

: Length = 2;

(Length < Code.size() &&

(Code[Length]))

(Length < Code.size()) {

= Code[Length];

isFloatingLiteral =

;

->Text = Code.substr(0, Length);

Code = Code.drop_front(Length);

(isFloatingLiteral) {

doubleValue = strtod(

.c_str(), &end);

(*end == 0 && errno == 0) {

->Value = doubleValue;

.End = currentLocation();

consumeStringLiteral(TokenInfo *

) {

InEscape =

;

Marker = Code[0];

(

Length = 1, Size = Code.size(); Length != Size; ++Length) {

(Code[Length] ==

) {

(Code[Length] == Marker) {

->Text = Code.substr(0, Length + 1);

->Value = Code.substr(1, Length - 1);

Code = Code.drop_front(Length + 1);

StringRef ErrorText = Code;

Code = Code.drop_front(Code.size());

.End = currentLocation();

consumeWhitespace() {

Code = Code.ltrim(

);

SourceLocation currentLocation() {

SourceLocation Location;

Location.Line = Line;

Location.Column = Code.data() - StartOfLine.data() + 1;

StringRef StartOfLine;

*CodeCompletionLocation =

;

std::vector<MatcherCompletion>

->ContextStack.push_back(std::make_pair(C, 0u));

->ContextStack.pop_back();

++

->ContextStack.back().second;

NamedValues ? NamedValues->lookup(NameToken.Text)

*

= NamedValue;

addCompletion(ChainCallToken, MatcherCompletion(

,

, 1));

Error->

(ChainCallToken.Range,

NameToken.Text, NameToken.Range);

Error->

(ChainCallToken.Range,

(!parseBindID(BindID))

assert(NamedValue.isMatcher());

std::optional<DynTypedMatcher>

=

NamedValue.getMatcher().getSingleMatcher();

std::optional<DynTypedMatcher> Bound =

->tryBind(BindID);

parseMatcherExpressionImpl(NameToken, OpenToken, Ctor,

);

Parser::parseBindID(std::string &BindID) {

BindID = IDToken.Value.getString();

Parser::parseMatcherBuilder(

Ctor,

TokenInfo &NameToken,

TokenInfo &OpenToken,

VariantValue *

) {

std::vector<ParserValue> Args;

ScopedContextEntry SCE(

, Ctor);

NameToken.Text, NameToken.Range,

ParserValue ArgValue;

addExpressionCompletions();

ArgValue.Text = NodeMatcherToken.Text;

ArgValue.Range = NodeMatcherToken.Range;

std::optional<MatcherCtor> MappedMatcher =

(!MappedMatcher) {

Error->

(NodeMatcherToken.Range,

<< NodeMatcherToken.Text;

Error->

(NodeMatcherToken.Range,

<< NodeMatcherToken.Text;

Args.push_back(ArgValue);

internal::MatcherDescriptorPtr BuiltCtor =

(!BuiltCtor.get()) {

addCompletion(ChainCallToken, MatcherCompletion(

,

, 1));

addCompletion(ChainCallToken, MatcherCompletion(

,

, 1));

Error->

(ChainCallToken.Range,

(!parseBindID(BindID))

NameToken.Text, NameToken.Range);

SourceRange MatcherRange = NameToken.Range;

MatcherRange.End = ChainCallToken.Range.End;

BuiltCtor.get(), MatcherRange, BindID, {}, Error);

: Tokenizer->peekNextToken().

;

parseMatcherExpressionImpl(NameToken, WithOpenToken,

BuiltCtor.get(),

);

NameToken.Text, NameToken.Range);

SourceRange MatcherRange = NameToken.Range;

MatcherRange.End = EndToken.Range.End;

BuiltCtor.get(), MatcherRange, BindID, {}, Error);

Parser::parseMatcherExpressionImpl(

TokenInfo &NameToken,

TokenInfo &OpenToken,

std::optional<MatcherCtor> Ctor,

VariantValue *

) {

parseMatcherBuilder(*Ctor, NameToken, OpenToken,

);

std::vector<ParserValue> Args;

ScopedContextEntry SCE(

, Ctor.value_or(

));

NameToken.Text, NameToken.Range,

ParserValue ArgValue;

(!parseExpressionImpl(&ArgValue.Value)) {

Args.push_back(ArgValue);

addCompletion(ChainCallToken, MatcherCompletion(

,

, 1));

Error->

(ChainCallToken.Range,

NameToken.Text, NameToken.Range);

Error->

(ChainCallToken.Range,

Error->

(ChainCallToken.Range,

(!parseBindID(BindID))

NameToken.Text, NameToken.Range);

SourceRange MatcherRange = NameToken.Range;

MatcherRange.End = EndToken.Range.End;

*Ctor, MatcherRange, BindID, Args, Error);

(

.isNull())

;

Parser::addCompletion(

TokenInfo &CompToken,

MatcherCompletion& Completion) {

(StringRef(Completion.TypedText).starts_with(CompToken.Text) &&

Completion.Specificity > 0) {

Completions.emplace_back(Completion.TypedText.substr(CompToken.Text.size()),

Completion.MatcherDecl, Completion.Specificity);

std::vector<MatcherCompletion> Parser::getNamedValueCompletions(

ArrayRef<ArgKind> AcceptedTypes) {

(!NamedValues)

std::vector<MatcherCompletion>();

std::vector<MatcherCompletion>

;

(

&Entry : *NamedValues) {

Specificity;

(Entry.getValue().isConvertibleTo(AcceptedTypes, &Specificity)) {

(Entry.getValue().getTypeAsString() +

+ Entry.getKey()).str();

.emplace_back(Entry.getKey(),

, Specificity);

Parser::addExpressionCompletions() {

(ContextStackTy::iterator I = ContextStack.begin(),

= ContextStack.end();

addCompletion(CompToken, Completion);

(

&Completion : getNamedValueCompletions(AcceptedTypes)) {

addCompletion(CompToken, Completion);

Parser::parseExpressionImpl(VariantValue *

) {

parseIdentifierPrefixImpl(

);

addExpressionCompletions();

llvm_unreachable(

);

Parser::Parser(CodeTokenizer *Tokenizer,

*S,

NamedValues(NamedValues), Error(Error) {}

Parser::RegistrySema::~RegistrySema() =

;

std::optional<MatcherCtor>

Parser::RegistrySema::lookupMatcherCtor(StringRef MatcherName) {

Registry::lookupMatcherCtor(MatcherName);

(BindID.empty()) {

Registry::constructMatcher(Ctor, NameRange, Args, Error);

Registry::constructBoundMatcher(Ctor, NameRange, BindID, Args,

std::vector<ArgKind> Parser::RegistrySema::getAcceptedCompletionTypes(

<std::pair<MatcherCtor, unsigned>> Context) {

Registry::getAcceptedCompletionTypes(Context);

std::vector<MatcherCompletion> Parser::RegistrySema::getMatcherCompletions(

Registry::getMatcherCompletions(AcceptedTypes);

Parser::RegistrySema::isBuilderMatcher(

Ctor)

{

Registry::isBuilderMatcher(Ctor);

Registry::nodeMatcherType(Ctor);

Registry::buildMatcherCtor(Ctor, NameRange, Args, Error);

Parser::parseExpression(StringRef &Code,

*S,

(!

(&Tokenizer, S, NamedValues, Error).parseExpressionImpl(

))

NT = Tokenizer.peekNextToken();

(NT.Kind != TokenInfo::TK_Eof && NT.Kind != TokenInfo::TK_NewLine) {

Error->addError(Tokenizer.peekNextToken().Range,

Error->ET_ParserTrailingCode);

std::vector<MatcherCompletion>

Parser::completeExpression(StringRef &Code,

CompletionOffset,

*S,

(&Tokenizer, S, NamedValues, &Error);

.parseExpressionImpl(&Dummy);

llvm::sort(

.Completions,

if (A.Specificity != B.Specificity)

return A.Specificity > B.Specificity;

return A.TypedText < B.TypedText;

.Completions;

std::optional<DynTypedMatcher>

Parser::parseMatcherExpression(StringRef &Code,

*S,

(!parseExpression(Code, S, NamedValues, &

, Error))

(!

.isMatcher()) {

Error->addError(

(), Error->ET_ParserNotAMatcher);

std::optional<DynTypedMatcher>

=

.getMatcher().getSingleMatcher();

Error->addError(

(), Error->ET_ParserOverloadedType)

<<

.getTypeAsString();

Simple matcher expression parser.

Diagnostics class to manage error messages.

Registry of all known matchers.

__device__ __2f16 float c

Sema - This implements semantic analysis and AST building for C.

Helper class to manage error messages.

ArgStream addError(SourceRange Range, ErrorType Error)

Add an error to the diagnostics.

@ ET_ParserMalformedBindExpr

@ ET_RegistryValueNotFound

@ ET_ParserFailedToBuildMatcher

@ ET_RegistryMatcherNotFound

@ ET_RegistryNonNodeMatcher

@ ET_ParserMalformedChainedExpr

@ ET_RegistryMatcherNoWithSupport

Simple tokenizer for the parser.

TokenInfo consumeNextTokenIgnoreNewlines()

CodeTokenizer(StringRef &MatcherCode, Diagnostics *Error, unsigned CodeCompletionOffset)

TokenInfo::TokenKind nextTokenKind() const

CodeTokenizer(StringRef &MatcherCode, Diagnostics *Error)

TokenInfo consumeNextToken()

Consumes and returns the next token.

const TokenInfo & peekNextToken() const

Returns but doesn't consume the next token.

Interface to connect the parser with the registry and more.

virtual VariantMatcher actOnMatcherExpression(MatcherCtor Ctor, SourceRange NameRange, StringRef BindID, ArrayRef< ParserValue > Args, Diagnostics *Error)=0

Process a matcher expression.

virtual internal::MatcherDescriptorPtr buildMatcherCtor(MatcherCtor, SourceRange NameRange, ArrayRef< ParserValue > Args, Diagnostics *Error) const =0

virtual std::optional< MatcherCtor > lookupMatcherCtor(StringRef MatcherName)=0

Look up a matcher by name.

virtual std::vector< ArgKind > getAcceptedCompletionTypes(llvm::ArrayRef< std::pair< MatcherCtor, unsigned > > Context)

Compute the list of completion types for Context.

virtual bool isBuilderMatcher(MatcherCtor) const =0

virtual std::vector< MatcherCompletion > getMatcherCompletions(llvm::ArrayRef< ArgKind > AcceptedTypes)

Compute the list of completions that match any of AcceptedTypes.

virtual ASTNodeKind nodeMatcherType(MatcherCtor) const =0

Matcher expression parser.

llvm::StringMap< VariantValue > NamedValueMap

A variant matcher object.

static VariantMatcher SingleMatcher(const DynTypedMatcher &Matcher)

Clones the provided matcher.

A smart (owning) pointer for MatcherDescriptor.

Matcher descriptor interface.

@ Decl

The l-value was an access to a declared entity or something equivalently strong, like the address of ...

static llvm::ManagedStatic< Parser::RegistrySema > DefaultRegistrySema

const internal::MatcherDescriptor * MatcherCtor

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

LLVM_READONLY char toLowercase(char c)

Converts the given ASCII character to its lowercase equivalent.

LLVM_READONLY bool isAlphanumeric(unsigned char c)

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

@ Result

The result type of a method or function.

LLVM_READONLY bool isHexDigit(unsigned char c)

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

ScopedContextEntry(Parser *P, MatcherCtor C)

Simple structure to hold information for one token from the parser.

TokenKind

Different possible tokens.

static const char *const ID_Bind

Some known identifiers.

static const char *const ID_With

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