|
1
19
20 package edu.umd.cs.findbugs.ba;
21
22 import java.io.IOException  ;
23 import java.util.HashSet ;
24 import java.util.List ;
25 import java.util.Set ;
26
27 import org.apache.bcel.Repository;
28 import org.apache.bcel.classfile.ClassFormatException;
29 import org.apache.bcel.classfile.JavaClass;
30
31 import edu.umd.cs.findbugs.AnalysisCacheToRepositoryAdapter;
32 import edu.umd.cs.findbugs.BugReporter;
33 import edu.umd.cs.findbugs.ba.ch.Subtypes;
34 import edu.umd.cs.findbugs.ba.npe.ParameterNullnessPropertyDatabase;
35 import edu.umd.cs.findbugs.ba.type.FieldStoreTypeDatabase;
36 import edu.umd.cs.findbugs.classfile.CheckedAnalysisException;
37 import edu.umd.cs.findbugs.classfile.ClassDescriptor;
38 import edu.umd.cs.findbugs.classfile.Global;
39 import edu.umd.cs.findbugs.classfile.MethodDescriptor;
40 import edu.umd.cs.findbugs.util.ClassName;
41
42
49 public class AnalysisCacheToAnalysisContextAdapter extends AnalysisContext {
50
51 static class DelegatingRepositoryLookupFailureCallback implements RepositoryLookupFailureCallback {
52
53
56 public void logError(String message) {
57 Global.getAnalysisCache().getErrorLogger().logError(message);
58 }
59
60
63 public void logError(String message, Throwable e) {
64 Global.getAnalysisCache().getErrorLogger().logError(message, e);
65 }
66
67
70 public void reportMissingClass(ClassNotFoundException ex) {
71 Global.getAnalysisCache().getErrorLogger().reportMissingClass(ex);
72 }
73
74
77 public void reportMissingClass(ClassDescriptor classDescriptor) {
78 Global.getAnalysisCache().getErrorLogger().reportMissingClass(classDescriptor);
79 }
80
81
84 public void reportSkippedAnalysis(MethodDescriptor method) {
85 Global.getAnalysisCache().getErrorLogger().reportSkippedAnalysis(method);
86 }
87
88 }
89
90 private RepositoryLookupFailureCallback lookupFailureCallback;
91
92
95 public AnalysisCacheToAnalysisContextAdapter() {
96 this.lookupFailureCallback = new DelegatingRepositoryLookupFailureCallback();
97 }
98
99
102 @Override
103 public void addApplicationClassToRepository(JavaClass appClass) {
104 throw new UnsupportedOperationException ();
105 }
106
107
110 @Override
111 public void addClasspathEntry(String url) throws IOException {
112 throw new UnsupportedOperationException ();
113 }
114
115
118 @Override
119 public void clearClassContextCache() {
120 throw new UnsupportedOperationException ();
121 }
122
123
126 @Override
127 public void clearRepository() {
128 Repository.setRepository(new AnalysisCacheToRepositoryAdapter());
131 }
132
133
136 @Override
137 public AnnotationRetentionDatabase getAnnotationRetentionDatabase() {
138 return getDatabase(AnnotationRetentionDatabase.class);
139 }
140
141
144 @Override
145 public CheckReturnAnnotationDatabase getCheckReturnAnnotationDatabase() {
146 return getDatabase(CheckReturnAnnotationDatabase.class);
147 }
148
149
152 @Override
153 public ClassContext getClassContext(JavaClass javaClass) {
154
157 ClassDescriptor classDescriptor =
158 new ClassDescriptor(ClassName.toSlashedClassName(javaClass.getClassName()));
159
160 try {
161 return Global.getAnalysisCache().getClassAnalysis(ClassContext.class, classDescriptor);
162 } catch (CheckedAnalysisException e) {
163 IllegalStateException ise = new IllegalStateException ("Could not get ClassContext for JavaClass");
164 ise.initCause(e);
165 throw ise;
166 }
167 }
168
169
172 @Override
173 public String getClassContextStats() {
174 return "<unknown ClassContext stats>";
175 }
176
177
180 @Override
181 public FieldStoreTypeDatabase getFieldStoreTypeDatabase() {
182 return getDatabase(FieldStoreTypeDatabase.class);
183 }
184
185
188 @Override
189 public JCIPAnnotationDatabase getJCIPAnnotationDatabase() {
190 return getDatabase(JCIPAnnotationDatabase.class);
191 }
192
193
196 @Override
197 public RepositoryLookupFailureCallback getLookupFailureCallback() {
198 return lookupFailureCallback;
199 }
200
201
204 @Override
205 public NullnessAnnotationDatabase getNullnessAnnotationDatabase() {
206 return getDatabase(NullnessAnnotationDatabase.class);
207 }
208
209
212 @Override
213 public SourceFinder getSourceFinder() {
214 return getDatabase(SourceFinder.class);
215 }
216
217
220 @Override
221 public SourceInfoMap getSourceInfoMap() {
222 return getDatabase(SourceInfoMap.class);
223 }
224
225
228 @Override
229 public Subtypes getSubtypes() {
230 return getDatabase(Subtypes.class);
231 }
232
233
236 @Override
237 public ParameterNullnessPropertyDatabase getUnconditionalDerefParamDatabase() {
238 return getDatabase(ParameterNullnessPropertyDatabase.class);
239 }
240
241
244 @Override
245 public void initDatabases() {
246 }
248
249
252 @Override
253 public JavaClass lookupClass(String className)
254 throws ClassNotFoundException {
255 try {
256 if (!ClassName.isValidClassName(className)) {
257 throw new ClassNotFoundException ("Invalid class name: " + className);
258 }
259 return Global.getAnalysisCache().getClassAnalysis(
260 JavaClass.class, new ClassDescriptor(ClassName.toSlashedClassName(className)));
261 } catch (CheckedAnalysisException e) {
262 throw new ClassNotFoundException ("Class not found: " + className, e);
263 }
264 }
265
266
269 @Override
270 public InnerClassAccessMap getInnerClassAccessMap() {
271 return getDatabase(InnerClassAccessMap.class);
272 }
273
274
282 private<E> E getDatabase(Class <E> cls) {
283 try {
284 return Global.getAnalysisCache().getDatabase(cls);
285 } catch (CheckedAnalysisException e) {
286 throw new IllegalStateException ("Could not get database " + cls.getName(), e);
287 }
288 }
289
290
296 public void setAppClassList(List <ClassDescriptor> appClassCollection) throws CheckedAnalysisException {
297
298
300 Subtypes subtypes = getSubtypes();
301
302 for (ClassDescriptor appClass : appClassCollection) {
303 try {
304 JavaClass jclass =
305 Global.getAnalysisCache().getClassAnalysis(JavaClass.class, appClass);
306 subtypes.addApplicationClass(jclass);
307 } catch (ClassFormatException e) {
308 Global.getAnalysisCache().getErrorLogger().logError(
309 "Error parsing application class " + appClass, e);
310 }
311 }
312
313 }
314
315
318 @Override
319 public void updateDatabases(int pass) {
320 if (pass == 0) {
321 getCheckReturnAnnotationDatabase().loadAuxiliaryAnnotations();
322 getNullnessAnnotationDatabase().loadAuxiliaryAnnotations();
323 }
324
325 }
326
327
328
329 }
330 |
Popular Tags |
Java API By Example, From Geeks To Geeks.