1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
/*******************************************************************************
* Copyright (c) 2006, 2009 Wind River Systems, Inc. and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Markus Schorn - initial API and implementation
*******************************************************************************/
package org.eclipse.cdt.internal.core.model.ext;
import org.eclipse.cdt.core.dom.ast.DOMException;
import org.eclipse.cdt.core.dom.ast.EScopeKind;
import org.eclipse.cdt.core.dom.ast.IBinding;
import org.eclipse.cdt.core.dom.ast.ICompositeType;
import org.eclipse.cdt.core.dom.ast.IEnumeration;
import org.eclipse.cdt.core.dom.ast.IEnumerator;
import org.eclipse.cdt.core.dom.ast.IField;
import org.eclipse.cdt.core.dom.ast.IFunction;
import org.eclipse.cdt.core.dom.ast.IParameter;
import org.eclipse.cdt.core.dom.ast.IScope;
import org.eclipse.cdt.core.dom.ast.ITypedef;
import org.eclipse.cdt.core.dom.ast.IVariable;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassTemplate;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPMethod;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPNamespace;
import org.eclipse.cdt.core.index.IIndexMacro;
import org.eclipse.cdt.core.model.ICElement;
import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jface.text.IRegion;
/**
* Factory for creating CElement handles. These are a minimal implementation
* of the ICElement interface and can be used for displaying information about
* the index.
* @since 4.0
*/
public class CElementHandleFactory {
private CElementHandleFactory() {}
public static ICElementHandle create(ITranslationUnit tu, IBinding binding, boolean isDefinition,
IRegion region, long timestamp) throws CoreException {
try {
return internalCreate(tu, binding, isDefinition, region, timestamp);
}
catch (DOMException e) {
return null;
}
}
public static ICElementHandle create(ITranslationUnit tu, IIndexMacro macro,
IRegion region, long timestamp) throws CoreException {
CElementHandle element= new MacroHandle(tu, macro);
if (region != null) {
element.setRangeOfID(region, timestamp);
}
return element;
}
public static ICElementHandle internalCreate(ITranslationUnit tu, IBinding binding, boolean definition,
IRegion region, long timestamp) throws CoreException, DOMException {
ICElement parentElement= createParent(tu, binding);
if (parentElement == null) {
return null;
}
CElementHandle element= null;
if (binding instanceof ICPPMethod) {
element= definition
? new MethodHandle(parentElement, (ICPPMethod) binding)
: new MethodDeclarationHandle(parentElement, (ICPPMethod) binding);
}
else if (binding instanceof IFunction) {
element= definition
? new FunctionHandle(parentElement, (IFunction) binding)
: new FunctionDeclarationHandle(parentElement, (IFunction) binding);
}
else if (binding instanceof IField) {
element= new FieldHandle(parentElement, (IField) binding);
}
else if (binding instanceof IVariable) {
if (binding instanceof IParameter) {
return null;
}
element= new VariableHandle(parentElement, (IVariable) binding);
}
else if (binding instanceof IEnumeration) {
element= new EnumerationHandle(parentElement, (IEnumeration) binding);
}
else if (binding instanceof IEnumerator) {
element= new EnumeratorHandle(parentElement, (IEnumerator) binding);
}
else if (binding instanceof ICompositeType) {
if (binding instanceof ICPPClassTemplate) {
element= new StructureTemplateHandle(parentElement, (ICompositeType) binding);
}
else {
element= new StructureHandle(parentElement, (ICompositeType) binding);
}
}
else if (binding instanceof ICPPNamespace) {
element= new NamespaceHandle(parentElement, (ICPPNamespace) binding);
}
else if (binding instanceof ITypedef) {
element= new TypedefHandle(parentElement, (ITypedef) binding);
}
if (element != null && region != null) {
element.setRangeOfID(region, timestamp);
}
return element;
}
private static ICElement createParent(ITranslationUnit tu, IBinding binding) throws DOMException {
IBinding parentBinding= binding.getOwner();
if (parentBinding == null) {
IScope scope= binding.getScope();
if (scope != null && scope.getKind() == EScopeKind.eLocal) {
return null;
}
return tu;
}
if (parentBinding instanceof ICPPNamespace) {
char[] scopeName= parentBinding.getNameCharArray();
if (scopeName.length != 0) {
// named namespace
ICElement grandParent= createParent(tu, parentBinding);
if (grandParent != null) {
return new NamespaceHandle(grandParent, (ICPPNamespace) parentBinding);
}
}
} else if (parentBinding instanceof ICompositeType) {
ICElement grandParent= createParent(tu, parentBinding);
if (grandParent != null) {
return new StructureHandle(grandParent, (ICompositeType) parentBinding);
}
}
return null;
}
}
|
