CloneSet69


Previous CloneSetNext CloneSetBack to Main Report
Clone
Mass
Clones in
CloneSet
Parameter
Count
Clone
Similarity
Syntax Category
[Sequence Length]
81950.955class_body_declaration
Clone AbstractionParameter Bindings
Clone Instance
(Click to see clone)
Line CountSource Line
Source File
18253
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
28346
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
38488
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
48512
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
58698
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
68852
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
781026
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
881137
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
981212
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
1071237
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
1171429
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
1281641
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
1381666
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
1471757
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
1581875
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
1681951
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
1781975
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
1882000
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
1982332
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java
Clone Instance
1
Line Count
8
Source Line
253
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         */
        public boolean match(ArrayAccess node, Object other) {
                if ( !(other instanceof ArrayAccess)) {
                        return false;
                }
                ArrayAccess o = (ArrayAccess) other;
                return (
                        safeSubtreeMatch(node.getArray(), o.getArray()) &&
                                   safeSubtreeMatch(node.getIndex(), o.getIndex()));
        }


Clone Instance
2
Line Count
8
Source Line
346
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         */
        public boolean match(AssertStatement node, Object other) {
                if ( !(other instanceof AssertStatement)) {
                        return false;
                }
                AssertStatement o = (AssertStatement) other;
                return (
                        safeSubtreeMatch(node.getExpression(), o.getExpression()) &&
                                   safeSubtreeMatch(node.getMessage(), o.getMessage()));
        }


Clone Instance
3
Line Count
8
Source Line
488
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         */
        public boolean match(CastExpression node, Object other) {
                if ( !(other instanceof CastExpression)) {
                        return false;
                }
                CastExpression o = (CastExpression) other;
                return (
                        safeSubtreeMatch(node.getType(), o.getType()) &&
                                   safeSubtreeMatch(node.getExpression(), o.getExpression()));
        }


Clone Instance
4
Line Count
8
Source Line
512
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         */
        public boolean match(CatchClause node, Object other) {
                if ( !(other instanceof CatchClause)) {
                        return false;
                }
                CatchClause o = (CatchClause) other;
                return (
                        safeSubtreeMatch(node.getException(), o.getException()) &&
                                   safeSubtreeMatch(node.getBody(), o.getBody()));
        }


Clone Instance
5
Line Count
8
Source Line
698
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         */
        public boolean match(DoStatement node, Object other) {
                if ( !(other instanceof DoStatement)) {
                        return false;
                }
                DoStatement o = (DoStatement) other;
                return (
                        safeSubtreeMatch(node.getExpression(), o.getExpression()) &&
                                   safeSubtreeMatch(node.getBody(), o.getBody()));
        }


Clone Instance
6
Line Count
8
Source Line
852
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         */
        public boolean match(FieldAccess node, Object other) {
                if ( !(other instanceof FieldAccess)) {
                        return false;
                }
                FieldAccess o = (FieldAccess) other;
                return (
                        safeSubtreeMatch(node.getExpression(), o.getExpression()) &&
                                   safeSubtreeMatch(node.getName(), o.getName()));
        }


Clone Instance
7
Line Count
8
Source Line
1026
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         */
        public boolean match(InstanceofExpression node, Object other) {
                if ( !(other instanceof InstanceofExpression)) {
                        return false;
                }
                InstanceofExpression o = (InstanceofExpression) other;
                return (
                                safeSubtreeMatch(node.getLeftOperand(), o.getLeftOperand()) &&
                                   safeSubtreeMatch(node.getRightOperand(), o.getRightOperand()));
        }


Clone Instance
8
Line Count
8
Source Line
1137
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         */
        public boolean match(LabeledStatement node, Object other) {
                if ( !(other instanceof LabeledStatement)) {
                        return false;
                }
                LabeledStatement o = (LabeledStatement) other;
                return (
                        safeSubtreeMatch(node.getLabel(), o.getLabel()) &&
                                   safeSubtreeMatch(node.getBody(), o.getBody()));
        }


Clone Instance
9
Line Count
8
Source Line
1212
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         * @since 3.0
         */
        public boolean match(MemberRef node, Object other) {
                if ( !(other instanceof MemberRef)) {
                        return false;
                }
                MemberRef o = (MemberRef) other;
                return (
                                safeSubtreeMatch(node.getQualifier(), o.getQualifier()) &&
                                   safeSubtreeMatch(node.getName(), o.getName()));
        }


Clone Instance
10
Line Count
7
Source Line
1237
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         * @since 3.1
         */
        public boolean match(MemberValuePair node, Object other) {
                if ( !(other instanceof MemberValuePair)) {
                        return false;
                }
                MemberValuePair o = (MemberValuePair) other;
                return (safeSubtreeMatch(node.getName(), o.getName()) &&
                                   safeSubtreeMatch(node.getValue(), o.getValue()));
        }


Clone Instance
11
Line Count
7
Source Line
1429
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         * @since 3.1
         */
        public boolean match(NormalAnnotation node, Object other) {
                if ( !(other instanceof NormalAnnotation)) {
                        return false;
                }
                NormalAnnotation o = (NormalAnnotation) other;
                return (safeSubtreeMatch(node.getTypeName(), o.getTypeName()) &&
                                           safeSubtreeListMatch(node.values(), o.values()));
        }


Clone Instance
12
Line Count
8
Source Line
1641
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         */
        public boolean match(QualifiedName node, Object other) {
                if ( !(other instanceof QualifiedName)) {
                        return false;
                }
                QualifiedName o = (QualifiedName) other;
                return (
                        safeSubtreeMatch(node.getQualifier(), o.getQualifier()) &&
                                   safeSubtreeMatch(node.getName(), o.getName()));
        }


Clone Instance
13
Line Count
8
Source Line
1666
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         * @since 3.1
         */
        public boolean match(QualifiedType node, Object other) {
                if ( !(other instanceof QualifiedType)) {
                        return false;
                }
                QualifiedType o = (QualifiedType) other;
                return (
                        safeSubtreeMatch(node.getQualifier(), o.getQualifier()) &&
                                   safeSubtreeMatch(node.getName(), o.getName()));
        }


Clone Instance
14
Line Count
7
Source Line
1757
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         * @since 3.1
         */
        public boolean match(SingleMemberAnnotation node, Object other) {
                if ( !(other instanceof SingleMemberAnnotation)) {
                        return false;
                }
                SingleMemberAnnotation o = (SingleMemberAnnotation) other;
                return (safeSubtreeMatch(node.getTypeName(), o.getTypeName()) &&
                                   safeSubtreeMatch(node.getValue(), o.getValue()));
        }


Clone Instance
15
Line Count
8
Source Line
1875
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         */
        public boolean match(SuperFieldAccess node, Object other) {
                if ( !(other instanceof SuperFieldAccess)) {
                        return false;
                }
                SuperFieldAccess o = (SuperFieldAccess) other;
                return (
                        safeSubtreeMatch(node.getName(), o.getName()) &&
                                   safeSubtreeMatch(node.getQualifier(), o.getQualifier()));
        }


Clone Instance
16
Line Count
8
Source Line
1951
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         */
        public boolean match(SwitchStatement node, Object other) {
                if ( !(other instanceof SwitchStatement)) {
                        return false;
                }
                SwitchStatement o = (SwitchStatement) other;
                return (
                        safeSubtreeMatch(node.getExpression(), o.getExpression()) &&
                                   safeSubtreeListMatch(node.statements(), o.statements()));
        }


Clone Instance
17
Line Count
8
Source Line
1975
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         */
        public boolean match(SynchronizedStatement node, Object other) {
                if ( !(other instanceof SynchronizedStatement)) {
                        return false;
                }
                SynchronizedStatement o = (SynchronizedStatement) other;
                return (
                        safeSubtreeMatch(node.getExpression(), o.getExpression()) &&
                                   safeSubtreeMatch(node.getBody(), o.getBody()));
        }


Clone Instance
18
Line Count
8
Source Line
2000
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         * @since 3.0
         */
        public boolean match(TagElement node, Object other) {
                if ( !(other instanceof TagElement)) {
                        return false;
                }
                TagElement o = (TagElement) other;
                return (
                                safeEquals(node.getTagName(), o.getTagName()) &&
                                   safeSubtreeListMatch(node.fragments(), o.fragments()));
        }


Clone Instance
19
Line Count
8
Source Line
2332
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTMatcher.java

        /**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         */
        public boolean match(WhileStatement node, Object other) {
                if ( !(other instanceof WhileStatement)) {
                        return false;
                }
                WhileStatement o = (WhileStatement) other;
                return (
                        safeSubtreeMatch(node.getExpression(), o.getExpression()) &&
                                   safeSubtreeMatch(node.getBody(), o.getBody()));
        }


Clone AbstractionParameter Count: 5Parameter Bindings

/**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         */
/**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         * @since 3.0
         */
/**
         * Returns whether the given node and the other object match.
         * <p>
         * The default implementation provided by this class tests whether the
         * other object is a node of the same type with structurally isomorphic
         * child subtrees. Subclasses may override this method as needed.
         * </p>
         * 
         * @param node the node
         * @param other the other object, or <code>null</code>
         * @return <code>true</code> if the subtree matches, or 
         *   <code>false</code> if they do not match or the other object has a
         *   different node type or is <code>null</code>
         * @since 3.1
         */
public boolean match( [[#variablebc00bea0]] node, Object other) {
  if ( !(other instanceof [[#variablebc00bea0]])) {
    return false;
  }
   [[#variablebc00bea0]] o = ( [[#variablebc00bea0]]) other;
  return ( [[#variablebc00be00]](node. [[#variablebc00b880]](), o. [[#variablebc00b880]]()) && [[#variablebc00bc20]](node. [[#variablebc00bdc0]](), o. [[#variablebc00bdc0]]()));
}
 

CloneAbstraction
Parameter Bindings
Parameter
Index
Clone
Instance
Parameter
Name
Value
11[[#bc00bea0]]
ArrayAccess 
12[[#bc00bea0]]
AssertStatement 
13[[#bc00bea0]]
CastExpression 
14[[#bc00bea0]]
CatchClause 
15[[#bc00bea0]]
DoStatement 
16[[#bc00bea0]]
FieldAccess 
17[[#bc00bea0]]
InstanceofExpression 
18[[#bc00bea0]]
LabeledStatement 
19[[#bc00bea0]]
MemberRef 
110[[#bc00bea0]]
MemberValuePair 
111[[#bc00bea0]]
NormalAnnotation 
112[[#bc00bea0]]
QualifiedName 
113[[#bc00bea0]]
QualifiedType 
114[[#bc00bea0]]
SingleMemberAnnotation 
115[[#bc00bea0]]
SuperFieldAccess 
116[[#bc00bea0]]
SwitchStatement 
117[[#bc00bea0]]
SynchronizedStatement 
118[[#bc00bea0]]
TagElement 
119[[#bc00bea0]]
WhileStatement 
21[[#bc00be00]]
safeSubtreeMatch 
22[[#bc00be00]]
safeSubtreeMatch 
23[[#bc00be00]]
safeSubtreeMatch 
24[[#bc00be00]]
safeSubtreeMatch 
25[[#bc00be00]]
safeSubtreeMatch 
26[[#bc00be00]]
safeSubtreeMatch 
27[[#bc00be00]]
safeSubtreeMatch 
28[[#bc00be00]]
safeSubtreeMatch 
29[[#bc00be00]]
safeSubtreeMatch 
210[[#bc00be00]]
safeSubtreeMatch 
211[[#bc00be00]]
safeSubtreeMatch 
212[[#bc00be00]]
safeSubtreeMatch 
213[[#bc00be00]]
safeSubtreeMatch 
214[[#bc00be00]]
safeSubtreeMatch 
215[[#bc00be00]]
safeSubtreeMatch 
216[[#bc00be00]]
safeSubtreeMatch 
217[[#bc00be00]]
safeSubtreeMatch 
218[[#bc00be00]]
safeEquals 
219[[#bc00be00]]
safeSubtreeMatch 
31[[#bc00b880]]
getArray 
32[[#bc00b880]]
getExpression 
33[[#bc00b880]]
getType 
34[[#bc00b880]]
getException 
35[[#bc00b880]]
getExpression 
36[[#bc00b880]]
getExpression 
37[[#bc00b880]]
getLeftOperand 
38[[#bc00b880]]
getLabel 
39[[#bc00b880]]
getQualifier 
310[[#bc00b880]]
getName 
311[[#bc00b880]]
getTypeName 
312[[#bc00b880]]
getQualifier 
313[[#bc00b880]]
getQualifier 
314[[#bc00b880]]
getTypeName 
315[[#bc00b880]]
getName 
316[[#bc00b880]]
getExpression 
317[[#bc00b880]]
getExpression 
318[[#bc00b880]]
getTagName 
319[[#bc00b880]]
getExpression 
41[[#bc00bc20]]
safeSubtreeMatch 
42[[#bc00bc20]]
safeSubtreeMatch 
43[[#bc00bc20]]
safeSubtreeMatch 
44[[#bc00bc20]]
safeSubtreeMatch 
45[[#bc00bc20]]
safeSubtreeMatch 
46[[#bc00bc20]]
safeSubtreeMatch 
47[[#bc00bc20]]
safeSubtreeMatch 
48[[#bc00bc20]]
safeSubtreeMatch 
49[[#bc00bc20]]
safeSubtreeMatch 
410[[#bc00bc20]]
safeSubtreeMatch 
411[[#bc00bc20]]
safeSubtreeListMatch 
412[[#bc00bc20]]
safeSubtreeMatch 
413[[#bc00bc20]]
safeSubtreeMatch 
414[[#bc00bc20]]
safeSubtreeMatch 
415[[#bc00bc20]]
safeSubtreeMatch 
416[[#bc00bc20]]
safeSubtreeListMatch 
417[[#bc00bc20]]
safeSubtreeMatch 
418[[#bc00bc20]]
safeSubtreeListMatch 
419[[#bc00bc20]]
safeSubtreeMatch 
51[[#bc00bdc0]]
getIndex 
52[[#bc00bdc0]]
getMessage 
53[[#bc00bdc0]]
getExpression 
54[[#bc00bdc0]]
getBody 
55[[#bc00bdc0]]
getBody 
56[[#bc00bdc0]]
getName 
57[[#bc00bdc0]]
getRightOperand 
58[[#bc00bdc0]]
getBody 
59[[#bc00bdc0]]
getName 
510[[#bc00bdc0]]
getValue 
511[[#bc00bdc0]]
values 
512[[#bc00bdc0]]
getName 
513[[#bc00bdc0]]
getName 
514[[#bc00bdc0]]
getValue 
515[[#bc00bdc0]]
getQualifier 
516[[#bc00bdc0]]
statements 
517[[#bc00bdc0]]
getBody 
518[[#bc00bdc0]]
fragments 
519[[#bc00bdc0]]
getBody