1
/*******************************************************************************
2
* Copyright (c) 2006, 2010 Wind River Systems, Inc. and others.
3
* All rights reserved. This program and the accompanying materials
4
* are made available under the terms of the Eclipse Public License v1.0
5
* which accompanies this distribution, and is available at
6
* http://www.eclipse.org/legal/epl-v10.html
9
* Markus Schorn - initial API and implementation
10
*******************************************************************************/
11
package org.eclipse.cdt.internal.core.pdom.indexer;
13
import java.util.ArrayList;
14
import java.util.List;
16
import org.eclipse.cdt.core.dom.ast.ASTVisitor;
17
import org.eclipse.cdt.core.dom.ast.IASTCompoundStatement;
18
import org.eclipse.cdt.core.dom.ast.IASTDeclSpecifier;
19
import org.eclipse.cdt.core.dom.ast.IASTDeclaration;
20
import org.eclipse.cdt.core.dom.ast.IASTDeclarator;
21
import org.eclipse.cdt.core.dom.ast.IASTExpression;
22
import org.eclipse.cdt.core.dom.ast.IASTFunctionDeclarator;
23
import org.eclipse.cdt.core.dom.ast.IASTFunctionDefinition;
24
import org.eclipse.cdt.core.dom.ast.IASTInitializer;
25
import org.eclipse.cdt.core.dom.ast.IASTName;
26
import org.eclipse.cdt.core.dom.ast.IASTNode;
27
import org.eclipse.cdt.core.dom.ast.IASTProblem;
28
import org.eclipse.cdt.core.dom.ast.IASTSimpleDeclaration;
29
import org.eclipse.cdt.core.dom.ast.c.ICASTCompositeTypeSpecifier;
30
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCapture;
31
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCompositeTypeSpecifier;
32
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTFunctionDeclarator;
33
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTLambdaExpression;
34
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTQualifiedName;
35
import org.eclipse.cdt.internal.core.dom.parser.ASTQueries;
37
abstract public class IndexerASTVisitor extends ASTVisitor {
38
private static class Definition {
39
Definition(IASTName name, IASTNode node) {
47
private IASTName fDefinitionName;
48
private IASTNode fDefinitionNode;
49
private ArrayList<Definition> fStack= new ArrayList<Definition>();
50
private ArrayList<IASTProblem> fProblems= new ArrayList<IASTProblem>();
52
public IndexerASTVisitor(boolean visitImplicitNames) {
53
shouldVisitNames= true;
54
shouldVisitImplicitNames = visitImplicitNames;
55
shouldVisitDeclarations= true;
56
shouldVisitInitializers= true;
57
shouldVisitDeclSpecifiers= true;
58
shouldVisitProblems= true;
59
shouldVisitExpressions= true;
62
public List<IASTProblem> getProblems() {
66
abstract public void visit(IASTName name, IASTName definitionName);
69
final public int visit(IASTName name) {
70
if (!(name instanceof ICPPASTQualifiedName)) {
71
if (name != fDefinitionName) {
72
visit(name, fDefinitionName);
75
return PROCESS_CONTINUE;
78
private void push(IASTName name, IASTNode node) {
79
if (fDefinitionName != null) {
80
fStack.add(new Definition(fDefinitionName, fDefinitionNode));
82
name = getLastInQualified(name);
83
fDefinitionName= name;
84
fDefinitionNode= node;
87
private IASTName getLastInQualified(IASTName name) {
88
if (name instanceof ICPPASTQualifiedName) {
89
name= ((ICPPASTQualifiedName) name).getLastName();
94
private void pop(IASTNode node) {
95
if (node == fDefinitionNode) {
96
if (fStack.isEmpty()) {
97
fDefinitionName= null;
98
fDefinitionNode= null;
101
Definition old= fStack.remove(fStack.size()-1);
102
fDefinitionName= old.fName;
103
fDefinitionNode= old.fNode;
108
// functions and methods
110
public int visit(IASTDeclaration decl) {
111
if (decl instanceof IASTFunctionDefinition) {
112
IASTFunctionDefinition fdef= (IASTFunctionDefinition) decl;
113
final IASTFunctionDeclarator declarator= fdef.getDeclarator();
114
IASTDeclarator nestedDeclarator= declarator;
115
while (nestedDeclarator.getNestedDeclarator() != null) {
116
nestedDeclarator= nestedDeclarator.getNestedDeclarator();
118
IASTName name= getLastInQualified(nestedDeclarator.getName());
119
visit(name, fDefinitionName);
121
} else if (decl instanceof IASTSimpleDeclaration) {
122
IASTSimpleDeclaration sdecl= (IASTSimpleDeclaration) decl;
123
if (sdecl.getDeclSpecifier().getStorageClass() == IASTDeclSpecifier.sc_typedef) {
124
IASTDeclarator[] declarators= sdecl.getDeclarators();
125
for (IASTDeclarator declarator : declarators) {
126
if (declarator.getPointerOperators().length == 0 &&
127
declarator.getNestedDeclarator() == null) {
128
IASTName name= getLastInQualified(declarator.getName());
129
visit(name, fDefinitionName);
135
return PROCESS_CONTINUE;
139
public int leave(IASTDeclaration decl) {
141
return PROCESS_CONTINUE;
144
// class definitions, typedefs
146
public int visit(IASTDeclSpecifier declspec) {
147
if (declspec instanceof ICPPASTCompositeTypeSpecifier) {
148
ICPPASTCompositeTypeSpecifier cts= (ICPPASTCompositeTypeSpecifier) declspec;
149
IASTName name = getLastInQualified(cts.getName());
150
visit(name, fDefinitionName);
151
push(name, declspec);
153
if (declspec instanceof ICASTCompositeTypeSpecifier) {
154
ICASTCompositeTypeSpecifier cts= (ICASTCompositeTypeSpecifier) declspec;
155
IASTName name = cts.getName();
156
visit(name, fDefinitionName);
157
push(name, declspec);
159
return PROCESS_CONTINUE;
163
public int leave(IASTDeclSpecifier declspec) {
165
return PROCESS_CONTINUE;
169
public int visit(IASTProblem problem) {
170
fProblems.add(problem);
174
// variable and field initializers
176
public int visit(IASTInitializer initializer) {
177
if (!(fDefinitionNode instanceof IASTFunctionDefinition)) {
178
IASTNode cand= initializer.getParent();
179
if (cand instanceof IASTDeclarator) {
180
cand= ASTQueries.findInnermostDeclarator((IASTDeclarator) cand);
181
push(((IASTDeclarator) cand).getName(), initializer);
184
return PROCESS_CONTINUE;
188
public int leave(IASTInitializer initializer) {
190
return PROCESS_CONTINUE;
193
// Lambda expressions
195
public int visit(IASTExpression expr) {
196
if (expr instanceof ICPPASTLambdaExpression) {
197
return visit((ICPPASTLambdaExpression) expr);
199
return PROCESS_CONTINUE;
202
private int visit(final ICPPASTLambdaExpression lambdaExpr) {
204
for (ICPPASTCapture cap : lambdaExpr.getCaptures()) {
205
if (!cap.accept(this))
206
return PROCESS_ABORT;
208
// Definition of closure type
209
final IASTName closureName = lambdaExpr.getClosureTypeName();
210
visit(closureName, fDefinitionName);
212
// Definition of call operator
213
IASTName callOp= lambdaExpr.getFunctionCallOperatorName();
214
visit(callOp, closureName);
215
push(callOp, lambdaExpr);
217
ICPPASTFunctionDeclarator dtor = lambdaExpr.getDeclarator();
218
if (dtor != null && !dtor.accept(this))
219
return PROCESS_ABORT;
221
IASTCompoundStatement body = lambdaExpr.getBody();
222
if (body != null && !body.accept(this))
223
return PROCESS_ABORT;
b'\\ No newline at end of file'