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

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

clang: lib/Tooling/ASTDiff/ASTDiff.cpp Source File

;

Mapping(Mapping &&

) =

;

Mapping &operator=(Mapping &&

) =

;

Mapping(

Size) {

SrcToDst = std::make_unique<NodeId[]>(Size);

DstToSrc = std::make_unique<NodeId[]>(Size);

(NodeId Src, NodeId Dst) {

SrcToDst[Src] = Dst, DstToSrc[Dst] = Src;

NodeId getDst(NodeId Src)

{

SrcToDst[Src]; }

NodeId getSrc(NodeId Dst)

{

DstToSrc[Dst]; }

hasSrc(NodeId Src)

{

getDst(Src).isValid(); }

hasDst(NodeId Dst)

{

getSrc(Dst).isValid(); }

std::unique_ptr<NodeId[]> SrcToDst, DstToSrc;

assert(&*

== &

&&

);

haveSameParents(

Mapping &M,

Id1,

Id2)

;

addOptimalMapping(Mapping &M,

Id1,

Id2)

;

getJaccardSimilarity(

Mapping &M,

Id1,

Id2)

;

findCandidate(

Mapping &M,

Id1)

;

Mapping matchTopDown()

;

matchBottomUp(Mapping &M)

;

setLeftMostDescendants();

= 0, Depth = 0;

PreorderVisitor(SyntaxTree::Impl &Tree) :

(

) {}

<

T> std::tuple<NodeId, NodeId> PreTraverse(

*ASTNode) {

.Nodes.emplace_back();

&N =

.getMutableNode(MyId);

assert(!N.ASTNode.getNodeKind().isNone() &&

);

.Children.push_back(MyId);

std::make_tuple(MyId,

.getNode(MyId).Parent);

PostTraverse(std::tuple<NodeId, NodeId> State) {

NodeId MyId, PreviousParent;

std::tie(MyId, PreviousParent) = State;

assert(MyId.isValid() &&

);

&N =

.getMutableNode(MyId);

N.RightMostDescendant =

- 1;

assert(N.RightMostDescendant >= 0 &&

N.RightMostDescendant <

.getSize() &&

);

.Leaves.push_back(MyId);

(NodeId Child : N.Children)

N.Height = std::max(N.Height, 1 +

.getNode(Child).Height);

TraverseDecl(

*

) {

SavedState = PreTraverse(

);

PostTraverse(SavedState);

TraverseStmt(

*S) {

(

*

= dyn_cast_or_null<Expr>(S))

SavedState = PreTraverse(S);

PostTraverse(SavedState);

TraverseType(

) {

; }

SavedState = PreTraverse(

);

PostTraverse(SavedState);

:

(

), AST(AST), TypePP(AST.getLangOpts()) {

PreorderVisitor PreorderWalker(*

);

PreorderWalker.TraverseDecl(N);

PreorderVisitor PreorderWalker(*

);

PreorderWalker.TraverseStmt(N);

std::vector<NodeId> Postorder;

Postorder.push_back(

);

std::vector<NodeId> Ids;

(Expanded < Ids.size())

(

Child :

.getNode(Ids[Expanded++]).Children)

Ids.push_back(Child);

SyntaxTree::Impl::initTree() {

setLeftMostDescendants();

PostorderIds.resize(

());

std::function<void(NodeId)> PostorderTraverse = [&](NodeId

) {

PostorderTraverse(Child);

PostorderIds[

] = PostorderId;

SyntaxTree::Impl::setLeftMostDescendants() {

(NodeId Leaf : Leaves) {

getMutableNode(Leaf).LeftMostDescendant = Leaf;

NodeId

, Cur = Leaf;

getMutableNode(Cur).LeftMostDescendant = Leaf;

(

I = 0,

= Siblings.size(); I <

; ++I) {

(Siblings[I] ==

) {

llvm_unreachable(

);

std::string ContextPrefix;

(

*Namespace = dyn_cast<NamespaceDecl>(Context))

ContextPrefix = Namespace->getQualifiedNameAsString();

(

*

= dyn_cast<RecordDecl>(Context))

ContextPrefix =

->getQualifiedNameAsString();

(AST.getLangOpts().CPlusPlus11)

(

*Tag = dyn_cast<TagDecl>(Context))

ContextPrefix = Tag->getQualifiedNameAsString();

(!ContextPrefix.empty() && StringRef(Val).starts_with(ContextPrefix))

Val = Val.substr(ContextPrefix.size() + 1);

&

= Parents[0];

(

*

=

.get<

>())

S =

.get<

>();

(

->isAnyMemberInitializer())

std::string(

->getAnyMember()->getName());

(

->isBaseInitializer())

(

->isDelegatingInitializer())

->getTypeSourceInfo()->getType().getAsString(TypePP);

llvm_unreachable(

);

(

*S = DTN.

<

>())

getStmtValue(S);

(

*

= DTN.

<

>())

getDeclValue(

);

llvm_unreachable(

);

(

*

= dyn_cast<ValueDecl>(

))

getRelativeName(

) +

+

->getType().getAsString(TypePP) +

;

(

*N = dyn_cast<NamedDecl>(

))

+= getRelativeName(N) +

;

(

*

= dyn_cast<TypedefNameDecl>(

))

+

->getUnderlyingType().getAsString(TypePP) +

;

(

*

= dyn_cast<TypeDecl>(

))

(

->getTypeForDecl())

(

*

= dyn_cast<UsingDirectiveDecl>(

))

std::string(

->getNominatedNamespace()->getName());

(

*A = dyn_cast<AccessSpecDecl>(

)) {

(

*

= dyn_cast<UnaryOperator>(S))

(

*B = dyn_cast<BinaryOperator>(S))

std::string(B->getOpcodeStr());

(

*M = dyn_cast<MemberExpr>(S))

getRelativeName(M->getMemberDecl());

(

*I = dyn_cast<IntegerLiteral>(S)) {

I->getValue().toString(Str,

10,

);

std::string(Str);

(

*F = dyn_cast<FloatingLiteral>(S)) {

F->getValue().toString(Str);

std::string(Str);

(

*

= dyn_cast<DeclRefExpr>(S))

(

*String = dyn_cast<StringLiteral>(S))

std::string(String->getString());

(

*B = dyn_cast<CXXBoolLiteralExpr>(S))

B->getValue() ?

:

;

()

{

; }

std::vector<NodeId> RootIds;

std::vector<SNodeId> LeftMostDescendants;

NumLeaves = setLeftMostDescendants();

computeKeyRoots(NumLeaves);

()

{

RootIds.size(); }

assert(

> 0 &&

<= getSize() &&

);

RootIds[

- 1];

.getNode(getIdInRoot(

));

assert(

> 0 &&

<= getSize() &&

);

LeftMostDescendants[

- 1];

.PostorderIds[getIdInRoot(

(1))];

.getNodeValue(getIdInRoot(

));

setLeftMostDescendants() {

LeftMostDescendants.resize(getSize());

(

I = 0; I < getSize(); ++I) {

NumLeaves += N.

();

assert(I ==

.PostorderIds[getIdInRoot(SI)] - getPostorderOffset() &&

);

getPostorderOffset());

computeKeyRoots(

Leaves) {

KeyRoots.resize(Leaves);

std::unordered_set<int>

;

(SNodeId I(getSize()); I > 0; --I) {

SNodeId LeftDesc = getLeftMostDescendant(I);

assert(K >= 0 &&

);

std::unique_ptr<std::unique_ptr<double[]>[]> TreeDist, ForestDist;

: DiffImpl(DiffImpl), S1(T1, Id1), S2(T2, Id2) {

TreeDist = std::make_unique<std::unique_ptr<double[]>[]>(

ForestDist = std::make_unique<std::unique_ptr<double[]>[]>(

(

I = 0,

= S1.

() + 1; I <

; ++I) {

TreeDist[I] = std::make_unique<double[]>(

(S2.

()) + 1);

ForestDist[I] = std::make_unique<double[]>(

(S2.

()) + 1);

std::vector<std::pair<NodeId, NodeId>> Matches;

std::vector<std::pair<SNodeId, SNodeId>> TreePairs;

RootNodePair =

;

(!TreePairs.empty()) {

LastRow, LastCol, FirstRow, FirstCol, Row, Col;

std::tie(LastRow, LastCol) = TreePairs.back();

TreePairs.pop_back();

computeForestDist(LastRow, LastCol);

RootNodePair =

;

(Row > FirstRow || Col > FirstCol) {

(Row > FirstRow &&

ForestDist[Row - 1][Col] + 1 == ForestDist[Row][Col]) {

}

(Col > FirstCol &&

ForestDist[Row][Col - 1] + 1 == ForestDist[Row][Col]) {

assert(DiffImpl.isMatchingPossible(Id1, Id2) &&

);

Matches.emplace_back(Id1, Id2);

TreePairs.emplace_back(Row, Col);

DeletionCost = 1;

InsertionCost = 1;

std::numeric_limits<double>::max();

computeTreeDist() {

computeForestDist(Id1, Id2);

computeForestDist(SNodeId Id1, SNodeId Id2) {

assert(Id1 > 0 && Id2 > 0 &&

);

ForestDist[LMD1][LMD2] = 0;

(SNodeId D1 = LMD1 + 1; D1 <= Id1; ++D1) {

ForestDist[D1][LMD2] = ForestDist[D1 - 1][LMD2] + DeletionCost;

(SNodeId D2 = LMD2 + 1; D2 <= Id2; ++D2) {

ForestDist[LMD1][D2] = ForestDist[LMD1][D2 - 1] + InsertionCost;

(DLMD1 == LMD1 && DLMD2 == LMD2) {

UpdateCost = getUpdateCost(D1, D2);

std::min({ForestDist[D1 - 1][D2] + DeletionCost,

ForestDist[D1][D2 - 1] + InsertionCost,

ForestDist[D1 - 1][D2 - 1] + UpdateCost});

TreeDist[D1][D2] = ForestDist[D1][D2];

std::min({ForestDist[D1 - 1][D2] + DeletionCost,

ForestDist[D1][D2 - 1] + InsertionCost,

ForestDist[DLMD1][DLMD2] + TreeDist[D1][D2]});

(

*ND = ASTNode.get<

>()) {

(ND->getDeclName().isIdentifier())

ND->getQualifiedNameAsString();

(

*ND = ASTNode.get<

>()) {

(ND->getDeclName().isIdentifier())

ND->getName();

operator()(NodeId Id1, NodeId Id2)

{

.getNode(Id1).Height <

.getNode(Id2).Height;

SyntaxTree::Impl &

;

std::vector<NodeId> Container;

PriorityQueue<NodeId, std::vector<NodeId>, HeightLess> List;

PriorityList(

SyntaxTree::Impl &

)

push(NodeId

) { List.push(

); }

std::vector<NodeId> pop() {

std::vector<NodeId> Result;

(peekMax() ==

) {

Result.push_back(List.top());

peekMax()

{

.getNode(List.top()).Height;

open(NodeId

) {

(NodeId Child :

.getNode(

).Children)

ASTDiff::Impl::identical(NodeId Id1, NodeId Id2)

{

&N1 = T1.getNode(Id1);

&N2 = T2.getNode(Id2);

(N1.Children.size() != N2.Children.size() ||

!isMatchingPossible(Id1, Id2) ||

T1.getNodeValue(Id1) != T2.getNodeValue(Id2))

(

= 0,

= N1.Children.size();

<

; ++

)

(!identical(N1.Children[

], N2.Children[

]))

ASTDiff::Impl::isMatchingPossible(NodeId Id1, NodeId Id2)

{

Options.isMatchingAllowed(T1.getNode(Id1), T2.getNode(Id2));

ASTDiff::Impl::haveSameParents(

Mapping &M, NodeId Id1,

NodeId P1 = T1.getNode(Id1).Parent;

NodeId P2 = T2.getNode(Id2).Parent;

(P1.isInvalid() && P2.isInvalid()) ||

(P1.isValid() && P2.isValid() && M.getDst(P1) == P2);

ASTDiff::Impl::addOptimalMapping(Mapping &M, NodeId Id1,

(std::max(T1.getNumberOfDescendants(Id1), T2.getNumberOfDescendants(Id2)) >

ZhangShashaMatcher Matcher(*

, T1, T2, Id1, Id2);

std::vector<std::pair<NodeId, NodeId>> R = Matcher.getMatchingNodes();

(

&Tuple : R) {

NodeId Src = Tuple.first;

NodeId Dst = Tuple.second;

(!M.hasSrc(Src) && !M.hasDst(Dst))

ASTDiff::Impl::getJaccardSimilarity(

Mapping &M, NodeId Id1,

CommonDescendants = 0;

&N1 = T1.getNode(Id1);

(NodeId Src = Id1 + 1; Src <= N1.RightMostDescendant; ++Src) {

NodeId Dst = M.getDst(Src);

CommonDescendants +=

(Dst.isValid() && T2.isInSubtree(Dst, Id2));

Denominator = T1.getNumberOfDescendants(Id1) - 1 +

T2.getNumberOfDescendants(Id2) - 1 - CommonDescendants;

assert(Denominator >= 0 &&

);

(Denominator == 0)

CommonDescendants / Denominator;

NodeId ASTDiff::Impl::findCandidate(

Mapping &M, NodeId Id1)

{

HighestSimilarity = 0.0;

(NodeId Id2 : T2) {

(!isMatchingPossible(Id1, Id2))

Similarity = getJaccardSimilarity(M, Id1, Id2);

(Similarity >= Options.MinSimilarity && Similarity > HighestSimilarity) {

HighestSimilarity = Similarity;

ASTDiff::Impl::matchBottomUp(Mapping &M)

{

(NodeId Id1 : Postorder) {

(Id1 == T1.getRootId() && !M.hasSrc(T1.getRootId()) &&

!M.hasDst(T2.getRootId())) {

(isMatchingPossible(T1.getRootId(), T2.getRootId())) {

M.link(T1.getRootId(), T2.getRootId());

addOptimalMapping(M, T1.getRootId(), T2.getRootId());

Matched = M.hasSrc(Id1);

&N1 = T1.getNode(Id1);

MatchedChildren = llvm::any_of(

N1.Children, [&](NodeId Child) { return M.hasSrc(Child); });

(Matched || !MatchedChildren)

NodeId Id2 = findCandidate(M, Id1);

addOptimalMapping(M, Id1, Id2);

Mapping ASTDiff::Impl::matchTopDown()

{

Mapping M(T1.getSize() + T2.getSize());

L1.push(T1.getRootId());

L2.push(T2.getRootId());

(std::min(Max1 = L1.peekMax(), Max2 = L2.peekMax()) >

(NodeId

: L1.pop())

(NodeId

: L2.pop())

std::vector<NodeId> H1, H2;

(NodeId Id1 : H1) {

(NodeId Id2 : H2) {

(identical(Id1, Id2) && !M.hasSrc(Id1) && !M.hasDst(Id2)) {

(

I = 0,

= T1.getNumberOfDescendants(Id1); I <

; ++I)

M.link(Id1 + I, Id2 + I);

(NodeId Id1 : H1) {

(NodeId Id2 : H2) {

: T1(T1), T2(T2), Options(Options) {

TheMapping = matchTopDown();

(Options.StopAfterTopDown)

matchBottomUp(TheMapping);

(!M.hasSrc(Id1)) {

T1.getMutableNode(Id1).Change =

;

T1.getMutableNode(Id1).Shift -= 1;

(!M.hasDst(Id2)) {

T2.getMutableNode(Id2).Change =

;

T2.getMutableNode(Id2).Shift -= 1;

(

Id1 : T1.NodesBfs) {

Id2 = M.getDst(Id1);

(!haveSameParents(M, Id1, Id2) ||

T1.findPositionInParent(Id1,

) !=

T2.findPositionInParent(Id2,

)) {

T1.getMutableNode(Id1).Shift -= 1;

T2.getMutableNode(Id2).Shift -= 1;

(

Id2 : T2.NodesBfs) {

Id1 = M.getSrc(Id2);

&N1 = T1.getMutableNode(Id1);

&N2 = T2.getMutableNode(Id2);

(!haveSameParents(M, Id1, Id2) ||

T1.findPositionInParent(Id1,

) !=

T2.findPositionInParent(Id2,

)) {

(T1.getNodeValue(Id1) != T2.getNodeValue(Id2)) {

: DiffImpl(

::make_unique<

>(*T1.TreeImpl, *T2.TreeImpl, Options)) {}

this, AST.getTranslationUnitDecl(), AST)) {}

std::pair<unsigned, unsigned>

(ThisExpr->isImplicit())

{

, End};

llvm::DenseSet< const void * > Visited

llvm::MachO::Record Record

static Expected< DynTypedNode > getNode(const ast_matchers::BoundNodes &Nodes, StringRef ID)

Defines the SourceManager interface.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

DynTypedNodeList getParents(const NodeT &Node)

Forwards to get node parents from the ParentMapContext.

Represents a C++ base or member initializer.

bool isWritten() const

Determine whether this initializer is explicitly written in the source code.

Represents the this expression in C++.

Represents a character-granular source range.

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

Decl - This represents one declaration (or definition), e.g.

bool isImplicit() const

isImplicit - Indicates whether the declaration was implicitly generated by the implementation.

DeclContext * getDeclContext()

const T * get() const

Retrieve the stored node as type T.

static DynTypedNode create(const T &Node)

Creates a DynTypedNode from Node.

Expr * IgnoreImplicit() LLVM_READONLY

Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.

static StringRef getSourceText(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts, bool *Invalid=nullptr)

Returns a string for the source that the range encompasses.

static SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset, const SourceManager &SM, const LangOptions &LangOpts)

Computes the source location just past the end of the token at this source location.

This represents a decl that may have a name.

std::string getQualifiedNameAsString() const

A (possibly-)qualified type.

static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)

A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...

bool TraverseStmt(Stmt *S, DataRecursionQueue *Queue=nullptr)

Recursively visit a statement or expression, by dispatching to Traverse*() based on the argument's dy...

bool TraverseDecl(Decl *D)

Recursively visit a declaration, by dispatching to Traverse*Decl() based on the argument's dynamic ty...

bool TraverseConstructorInitializer(CXXCtorInitializer *Init)

Recursively visit a constructor initializer.

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.

unsigned getFileOffset(SourceLocation SpellingLoc) const

Returns the offset from the start of the file that the specified SourceLocation represents.

bool isInMainFile(SourceLocation Loc) const

Returns whether the PresumedLoc for a given SourceLocation is in the main file.

SourceLocation getSpellingLoc(SourceLocation Loc) const

Given a SourceLocation object, return the spelling location referenced by the ID.

SourceLocation getExpansionLoc(SourceLocation Loc) const

Given a SourceLocation object Loc, return the expansion location referenced by the ID.

A trivial tuple used to represent a source range.

SourceLocation getEnd() const

SourceLocation getBegin() const

Stmt - This represents one statement.

QualType getCanonicalTypeInternal() const

static StringRef getOpcodeStr(Opcode Op)

getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to,...

void computeChangeKinds(Mapping &M)

NodeId getMapped(const std::unique_ptr< SyntaxTree::Impl > &Tree, NodeId Id) const

Impl(SyntaxTree::Impl &T1, SyntaxTree::Impl &T2, const ComparisonOptions &Options)

void computeMapping()

Matches nodes one-by-one based on their similarity.

ASTDiff(SyntaxTree &Src, SyntaxTree &Dst, const ComparisonOptions &Options)

NodeId getMapped(const SyntaxTree &SourceTree, NodeId Id) const

const Node & getNode(SNodeId Id) const

SNodeId getLeftMostDescendant(SNodeId Id) const

Subtree(const SyntaxTree::Impl &Tree, NodeId SubtreeRoot)

std::vector< SNodeId > KeyRoots

NodeId getPostorderOffset() const

Returns the postorder index of the leftmost descendant in the subtree.

NodeId getIdInRoot(SNodeId Id) const

std::string getNodeValue(SNodeId Id) const

Represents the AST of a TranslationUnit.

std::string getRelativeName(const NamedDecl *ND, const DeclContext *Context) const

int getNumberOfDescendants(NodeId Id) const

bool isValidNodeId(NodeId Id) const

std::vector< NodeId > Leaves

bool isInSubtree(NodeId Id, NodeId SubtreeRoot) const

PreorderIterator begin() const

std::vector< Node > Nodes

Nodes in preorder.

PreorderIterator end() const

int findPositionInParent(NodeId Id, bool Shifted=false) const

const Node & getNode(NodeId Id) const

std::string getStmtValue(const Stmt *S) const

std::vector< int > PostorderIds

std::string getNodeValue(NodeId Id) const

Impl(SyntaxTree *Parent, std::enable_if_t< std::is_base_of_v< Decl, T >, T > *Node, ASTContext &AST)

Impl(SyntaxTree *Parent, std::enable_if_t< std::is_base_of_v< Stmt, T >, T > *Node, ASTContext &AST)

std::string getDeclValue(const Decl *D) const

std::vector< NodeId > NodesBfs

Impl(SyntaxTree *Parent, ASTContext &AST)

Node & getMutableNode(NodeId Id)

SyntaxTree objects represent subtrees of the AST.

const Node & getNode(NodeId Id) const

int findPositionInParent(NodeId Id) const

const ASTContext & getASTContext() const

PreorderIterator begin() const

std::pair< unsigned, unsigned > getSourceRangeOffsets(const Node &N) const

SyntaxTree(ASTContext &AST)

Constructs a tree from a translation unit.

std::unique_ptr< Impl > TreeImpl

PreorderIterator end() const

std::string getNodeValue(NodeId Id) const

Serialize the node attributes to a string representation.

Implementation of Zhang and Shasha's Algorithm for tree edit distance.

ZhangShashaMatcher(const ASTDiff::Impl &DiffImpl, const SyntaxTree::Impl &T1, const SyntaxTree::Impl &T2, NodeId Id1, NodeId Id2)

std::vector< std::pair< NodeId, NodeId > > getMatchingNodes()

static bool isSpecializedNodeExcluded(const Decl *D)

static const DeclContext * getEnclosingDeclContext(ASTContext &AST, const Stmt *S)

DynTypedNode DynTypedNode

static std::vector< NodeId > getSubtreePostorder(const SyntaxTree::Impl &Tree, NodeId Root)

static std::vector< NodeId > getSubtreeBfs(const SyntaxTree::Impl &Tree, NodeId Root)

static bool isNodeExcluded(const SourceManager &SrcMgr, T *N)

static std::string getInitializerValue(const CXXCtorInitializer *Init, const PrintingPolicy &TypePP)

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

const FunctionProtoType * T

@ Other

Other implicit parameter.

bool link(llvm::ArrayRef< const char * > args, llvm::raw_ostream &stdoutOS, llvm::raw_ostream &stderrOS, bool exitEarly, bool disableOutput)

Diagnostic wrappers for TextAPI types for error reporting.

Describes how types, statements, expressions, and declarations should be printed.

unsigned AnonymousTagLocations

When printing an anonymous tag name, also print the location of that entity (e.g.,...

Within a tree, this identifies a node by its preorder offset.

Represents a Clang AST node, alongside some additional information.

NodeId RightMostDescendant

std::optional< std::string > getQualifiedIdentifier() const

std::optional< StringRef > getIdentifier() const

ASTNodeKind getType() const

NodeId LeftMostDescendant

StringRef getTypeLabel() const

SmallVector< NodeId, 4 > Children

Identifies a node in a subtree by its postorder offset, starting at 1.

SNodeId operator+(int Other) const

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