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

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

clang: lib/Tooling/Transformer/Parsing.cpp Source File

;

transformer;

<

... Ts>

RangeSelectorOp =

(*)(Ts...);

StringRef OriginalInput;

<

ResultType>

ParseProgress {

<

T>

ParseFunction = ExpectedProgress<T> (*)(ParseState);

:

llvm::ErrorInfo<ParseError> {

(

Pos, std::string ErrorMsg, std::string InputExcerpt)

: Pos(Pos), ErrorMsg(

::move(ErrorMsg)),

Excerpt(

::move(InputExcerpt)) {}

(llvm::raw_ostream &OS)

{

OS <<

<< Pos <<

<< ErrorMsg

std::error_code convertToErrorCode()

{

llvm::inconvertibleErrorCode();

llvm::StringMap<RangeSelectorOp<std::string>> &

llvm::StringMap<RangeSelectorOp<std::string>> M = {

llvm::StringMap<RangeSelectorOp<RangeSelector>> &

llvm::StringMap<RangeSelectorOp<RangeSelector>> M = {

llvm::StringMap<RangeSelectorOp<std::string, std::string>> &

llvm::StringMap<RangeSelectorOp<std::string, std::string>> M = {

llvm::StringMap<RangeSelectorOp<RangeSelector, RangeSelector>> &

llvm::StringMap<RangeSelectorOp<RangeSelector, RangeSelector>>

<

Element>

std::optional<Element>

(

llvm::StringMap<Element> &Map,

llvm::StringRef Key) {

it = Map.find(Key);

<

ResultType>

ParseProgress<ResultType>{State, std::move(Result)};

Pos = S.OriginalInput.size() - S.Input.size();

llvm::make_error<ParseError>(Pos, std::move(ErrorMsg),

S.OriginalInput.substr(Pos, 20).str());

ParseState

(ParseState S,

N) {

S.Input = S.Input.drop_front(N);

ExpectedProgress<std::nullopt_t>

(

, ParseState State) {

(State.Input.empty() || State.Input.front() !=

)

(

+ llvm::Twine(

)).str());

ExpectedProgress<std::string>

(ParseState State) {

= State.Input.take_while(

(State.Input.empty())

(!State.Input.consume_front(

))

);

StringRef

= State.Input.take_until([](

) {

==

; });

(State.Input.size() ==

.size())

<

T>

ExpectedProgress<RangeSelector>

(ParseFunction<T> ParseElement,

RangeSelectorOp<T> Op,

.takeError();

= ParseElement(

->State);

.takeError();

.takeError();

<

T>

ExpectedProgress<RangeSelector>

(ParseFunction<T> ParseElement,

RangeSelectorOp<T, T> Op,

.takeError();

Left = ParseElement(

->State);

Left.takeError();

.takeError();

Right = ParseElement(

->State);

Right.takeError();

.takeError();

Op(std::move(Left->Value), std::move(Right->Value)));

ExpectedProgress<RangeSelector>

.takeError();

std::string OpName = std::move(

->Value);

(State,

+ OpName);

ParseState State = {Input, Input};

Result.takeError();

State = Result->State;

(State.Input.empty())

Result->Value;

(State,

);

static ExpectedProgress< std::string > parseStringId(ParseState State)

static ExpectedProgress< std::nullopt_t > parseChar(char c, ParseState State)

ParseProgress< ResultType > makeParseProgress(ParseState State, ResultType Result)

static StringRef consumeWhitespace(StringRef S)

ExpectedProgress< RangeSelector > parseSingle(ParseFunction< T > ParseElement, RangeSelectorOp< T > Op, ParseState State)

ExpectedProgress< RangeSelector > parsePair(ParseFunction< T > ParseElement, RangeSelectorOp< T, T > Op, ParseState State)

std::optional< Element > findOptional(const llvm::StringMap< Element > &Map, llvm::StringRef Key)

static llvm::Error makeParseError(const ParseState &S, std::string ErrorMsg)

static const llvm::StringMap< RangeSelectorOp< RangeSelector > > & getUnaryRangeSelectors()

static ExpectedProgress< RangeSelector > parseRangeSelectorImpl(ParseState State)

static ExpectedProgress< std::string > parseId(ParseState State)

static ParseState advance(ParseState S, size_t N)

static const llvm::StringMap< RangeSelectorOp< RangeSelector, RangeSelector > > & getBinaryRangeSelectors()

static const llvm::StringMap< RangeSelectorOp< std::string, std::string > > & getBinaryStringSelectors()

static const llvm::StringMap< RangeSelectorOp< std::string > > & getUnaryStringSelectors()

Defines parsing functions for Transformer types.

Defines a combinator library supporting the definition of selectors, which select source ranges based...

Defines the clang::SourceLocation class and associated facilities.

__device__ __2f16 float c

RangeSelector initListElements(std::string ID)

RangeSelector enclose(RangeSelector Begin, RangeSelector End)

Selects from the start of Begin and to the end of End.

RangeSelector member(std::string ID)

Given a MemberExpr, selects the member token.

RangeSelector between(RangeSelector R1, RangeSelector R2)

Selects the range between R1 and `R2.

RangeSelector elseBranch(std::string ID)

Given an \IfStmt (bound to ID), selects the range of the else branch, starting from the else keyword.

RangeSelector node(std::string ID)

Selects a node, including trailing semicolon, if any (for declarations and non-expression statements)...

MatchConsumer< CharSourceRange > RangeSelector

RangeSelector encloseNodes(std::string BeginID, std::string EndID)

Convenience version of range where end-points are bound nodes.

RangeSelector after(RangeSelector Selector)

Selects the point immediately following Selector.

RangeSelector callArgs(std::string ID)

RangeSelector before(RangeSelector Selector)

Selects the (empty) range [B,B) when Selector selects the range [B,E).

llvm::Expected< RangeSelector > parseRangeSelector(llvm::StringRef Input)

Parses a string representation of a RangeSelector.

RangeSelector statement(std::string ID)

Selects a node, including trailing semicolon (always).

RangeSelector expansion(RangeSelector S)

Selects the range from which S was expanded (possibly along with other source), if S is an expansion,...

RangeSelector statements(std::string ID)

RangeSelector name(std::string ID)

Given a node with a "name", (like NamedDecl, DeclRefExpr, CxxCtorInitializer, and TypeLoc) selects th...

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

LLVM_READNONE bool isASCII(char c)

Returns true if a byte is an ASCII character.

LLVM_READONLY bool isAsciiIdentifierContinue(unsigned char c)

LLVM_READONLY bool isWhitespace(unsigned char c)

Return true if this character is horizontal or vertical ASCII whitespace: ' ', '\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