1 package org.apache.bcel.generic;
2
3 /* ====================================================================
4 * The Apache Software License, Version 1.1
5 *
6 * Copyright (c) 2001 The Apache Software Foundation. All rights
7 * reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 *
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 *
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in
18 * the documentation and/or other materials provided with the
19 * distribution.
20 *
21 * 3. The end-user documentation included with the redistribution,
22 * if any, must include the following acknowledgment:
23 * "This product includes software developed by the
24 * Apache Software Foundation (http://www.apache.org/)."
25 * Alternately, this acknowledgment may appear in the software itself,
26 * if and wherever such third-party acknowledgments normally appear.
27 *
28 * 4. The names "Apache" and "Apache Software Foundation" and
29 * "Apache BCEL" must not be used to endorse or promote products
30 * derived from this software without prior written permission. For
31 * written permission, please contact apache@apache.org.
32 *
33 * 5. Products derived from this software may not be called "Apache",
34 * "Apache BCEL", nor may "Apache" appear in their name, without
35 * prior written permission of the Apache Software Foundation.
36 *
37 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
38 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
39 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
40 * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
41 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
42 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
43 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
44 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
45 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
46 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
47 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
48 * SUCH DAMAGE.
49 * ====================================================================
50 *
51 * This software consists of voluntary contributions made by many
52 * individuals on behalf of the Apache Software Foundation. For more
53 * information on the Apache Software Foundation, please see
54 * <http://www.apache.org/>.
55 */
56
57 import org.apache.bcel.Constants;
58 import org.apache.bcel.Repository;
59 import org.apache.bcel.classfile.JavaClass;
60
61 /***
62 * Super class for object and array types.
63 *
64 * @version $Id: ReferenceType.java,v 1.5 2002/08/07 18:01:32 mdahm Exp $
65 * @author <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
66 */
67 public abstract class ReferenceType extends Type {
68 protected ReferenceType(byte t, String s) {
69 super(t, s);
70 }
71
72 /*** Class is non-abstract but not instantiable from the outside
73 */
74 ReferenceType() {
75 super(Constants.T_OBJECT, "<null object>");
76 }
77
78 /***
79 * Return true iff this type is castable to another type t as defined in
80 * the JVM specification. The case where this is Type.NULL is not
81 * defined (see the CHECKCAST definition in the JVM specification).
82 * However, because e.g. CHECKCAST doesn't throw a
83 * ClassCastException when casting a null reference to any Object,
84 * true is returned in this case.
85 */
86 public boolean isCastableTo(Type t) {
87 if (this.equals(Type.NULL))
88 return true; // If this is ever changed in isAssignmentCompatible()
89
90 return isAssignmentCompatibleWith(t);
91 /* Yes, it's true: It's the same definition.
92 * See vmspec2 AASTORE / CHECKCAST definitions.
93 */
94 }
95
96 /***
97 * Return true iff this is assignment compatible with another type t
98 * as defined in the JVM specification; see the AASTORE definition
99 * there.
100 */
101 public boolean isAssignmentCompatibleWith(Type t) {
102 if (!(t instanceof ReferenceType))
103 return false;
104
105 ReferenceType T = (ReferenceType) t;
106
107 if (this.equals(Type.NULL))
108 return true; // This is not explicitely stated, but clear. Isn't it?
109
110 /* If this is a class type then
111 */
112 if ((this instanceof ObjectType) && (((ObjectType) this).referencesClass())) {
113 /* If T is a class type, then this must be the same class as T,
114 or this must be a subclass of T;
115 */
116 if ((T instanceof ObjectType) && (((ObjectType) T).referencesClass())) {
117 if (this.equals(T))
118 return true;
119
120 if (Repository.instanceOf(((ObjectType) this).getClassName(),
121 ((ObjectType) T).getClassName()))
122 return true;
123 }
124
125 /* If T is an interface type, this must implement interface T.
126 */
127 if ((T instanceof ObjectType) && (((ObjectType) T).referencesInterface())) {
128 if (Repository.implementationOf(((ObjectType) this).getClassName(),
129 ((ObjectType) T).getClassName()))
130 return true;
131 }
132 }
133
134 /* If this is an interface type, then:
135 */
136 if ((this instanceof ObjectType) && (((ObjectType) this).referencesInterface())) {
137 /* If T is a class type, then T must be Object (§2.4.7).
138 */
139 if ((T instanceof ObjectType) && (((ObjectType) T).referencesClass())) {
140 if (T.equals(Type.OBJECT)) return true;
141 }
142
143 /* If T is an interface type, then T must be the same interface
144 * as this or a superinterface of this (§2.13.2).
145 */
146 if ((T instanceof ObjectType) && (((ObjectType) T).referencesInterface())) {
147 if (this.equals(T)) return true;
148 if (Repository.implementationOf(((ObjectType) this).getClassName(),
149 ((ObjectType) T).getClassName()))
150 return true;
151 }
152 }
153
154 /* If this is an array type, namely, the type SC[], that is, an
155 * array of components of type SC, then:
156 */
157 if (this instanceof ArrayType) {
158 /* If T is a class type, then T must be Object (§2.4.7).
159 */
160 if ((T instanceof ObjectType) && (((ObjectType) T).referencesClass())) {
161 if (T.equals(Type.OBJECT)) return true;
162 }
163
164 /* If T is an array type TC[], that is, an array of components
165 * of type TC, then one of the following must be true:
166 */
167 if (T instanceof ArrayType) {
168 /* TC and SC are the same primitive type (§2.4.1).
169 */
170 Type sc = ((ArrayType) this).getElementType();
171 Type tc = ((ArrayType) this).getElementType();
172
173 if (sc instanceof BasicType && tc instanceof BasicType && sc.equals(tc))
174 return true;
175
176 /* TC and SC are reference types (§2.4.6), and type SC is
177 * assignable to TC by these runtime rules.
178 */
179 if (tc instanceof ReferenceType && sc instanceof ReferenceType &&
180 ((ReferenceType) sc).isAssignmentCompatibleWith((ReferenceType) tc))
181 return true;
182 }
183
184 /* If T is an interface type, T must be one of the interfaces implemented by arrays (§2.15). */
185 // TODO: Check if this is still valid or find a way to dynamically find out which
186 // interfaces arrays implement. However, as of the JVM specification edition 2, there
187 // are at least two different pages where assignment compatibility is defined and
188 // on one of them "interfaces implemented by arrays" is exchanged with "'Cloneable' or
189 // 'java.io.Serializable'"
190 if ((T instanceof ObjectType) && (((ObjectType) T).referencesInterface())) {
191 for (int ii = 0; ii < Constants.INTERFACES_IMPLEMENTED_BY_ARRAYS.length; ii++) {
192 if (T.equals(new ObjectType(Constants.INTERFACES_IMPLEMENTED_BY_ARRAYS[ii]))) return true;
193 }
194 }
195 }
196 return false; // default.
197 }
198
199 /***
200 * This commutative operation returns the first common superclass (narrowest ReferenceType
201 * referencing a class, not an interface).
202 * If one of the types is a superclass of the other, the former is returned.
203 * If "this" is Type.NULL, then t is returned.
204 * If t is Type.NULL, then "this" is returned.
205 * If "this" equals t ['this.equals(t)'] "this" is returned.
206 * If "this" or t is an ArrayType, then Type.OBJECT is returned;
207 * unless their dimensions match. Then an ArrayType of the same
208 * number of dimensions is returned, with its basic type being the
209 * first common super class of the basic types of "this" and t.
210 * If "this" or t is a ReferenceType referencing an interface, then Type.OBJECT is returned.
211 * If not all of the two classes' superclasses cannot be found, "null" is returned.
212 * See the JVM specification edition 2, "§4.9.2 The Bytecode Verifier".
213 */
214 public ReferenceType getFirstCommonSuperclass(ReferenceType t) {
215 if (this.equals(Type.NULL)) return t;
216 if (t.equals(Type.NULL)) return this;
217 if (this.equals(t)) return this;
218 /*
219 * TODO: Above sounds a little arbitrary. On the other hand, there is
220 * no object referenced by Type.NULL so we can also say all the objects
221 * referenced by Type.NULL were derived from java.lang.Object.
222 * However, the Java Language's "instanceof" operator proves us wrong:
223 * "null" is not referring to an instance of java.lang.Object :)
224 */
225
226 /* This code is from a bug report by Konstantin Shagin <konst@cs.technion.ac.il> */
227
228 if ((this instanceof ArrayType) && (t instanceof ArrayType)) {
229 ArrayType arrType1 = (ArrayType) this;
230 ArrayType arrType2 = (ArrayType) t;
231 if (
232 (arrType1.getDimensions() == arrType2.getDimensions()) &&
233 arrType1.getBasicType() instanceof ObjectType &&
234 arrType2.getBasicType() instanceof ObjectType) {
235 return new ArrayType(
236 ((ObjectType) arrType1.getBasicType()).getFirstCommonSuperclass((ObjectType) arrType2.getBasicType()),
237 arrType1.getDimensions()
238 );
239
240 }
241 }
242
243 if ((this instanceof ArrayType) || (t instanceof ArrayType))
244 return Type.OBJECT;
245 // TODO: Is there a proof of OBJECT being the direct ancestor of every ArrayType?
246
247 if (((this instanceof ObjectType) && ((ObjectType) this).referencesInterface()) ||
248 ((t instanceof ObjectType) && ((ObjectType) t).referencesInterface()))
249 return Type.OBJECT;
250 // TODO: The above line is correct comparing to the vmspec2. But one could
251 // make class file verification a bit stronger here by using the notion of
252 // superinterfaces or even castability or assignment compatibility.
253
254
255 // this and t are ObjectTypes, see above.
256 ObjectType thiz = (ObjectType) this;
257 ObjectType other = (ObjectType) t;
258 JavaClass[] thiz_sups = Repository.getSuperClasses(thiz.getClassName());
259 JavaClass[] other_sups = Repository.getSuperClasses(other.getClassName());
260
261 if ((thiz_sups == null) || (other_sups == null)) {
262 return null;
263 }
264
265 // Waaahh...
266 JavaClass[] this_sups = new JavaClass[thiz_sups.length + 1];
267 JavaClass[] t_sups = new JavaClass[other_sups.length + 1];
268 System.arraycopy(thiz_sups, 0, this_sups, 1, thiz_sups.length);
269 System.arraycopy(other_sups, 0, t_sups, 1, other_sups.length);
270 this_sups[0] = Repository.lookupClass(thiz.getClassName());
271 t_sups[0] = Repository.lookupClass(other.getClassName());
272
273 for (int i = 0; i < t_sups.length; i++) {
274 for (int j = 0; j < this_sups.length; j++) {
275 if (this_sups[j].equals(t_sups[i])) return new ObjectType(this_sups[j].getClassName());
276 }
277 }
278
279 // Huh? Did you ask for Type.OBJECT's superclass??
280 return null;
281 }
282
283 /***
284 * This commutative operation returns the first common superclass (narrowest ReferenceType
285 * referencing a class, not an interface).
286 * If one of the types is a superclass of the other, the former is returned.
287 * If "this" is Type.NULL, then t is returned.
288 * If t is Type.NULL, then "this" is returned.
289 * If "this" equals t ['this.equals(t)'] "this" is returned.
290 * If "this" or t is an ArrayType, then Type.OBJECT is returned.
291 * If "this" or t is a ReferenceType referencing an interface, then Type.OBJECT is returned.
292 * If not all of the two classes' superclasses cannot be found, "null" is returned.
293 * See the JVM specification edition 2, "§4.9.2 The Bytecode Verifier".
294 *
295 * @deprecated use getFirstCommonSuperclass(ReferenceType t) which has
296 * slightly changed semantics.
297 */
298 public ReferenceType firstCommonSuperclass(ReferenceType t) {
299 if (this.equals(Type.NULL)) return t;
300 if (t.equals(Type.NULL)) return this;
301 if (this.equals(t)) return this;
302 /*
303 * TODO: Above sounds a little arbitrary. On the other hand, there is
304 * no object referenced by Type.NULL so we can also say all the objects
305 * referenced by Type.NULL were derived from java.lang.Object.
306 * However, the Java Language's "instanceof" operator proves us wrong:
307 * "null" is not referring to an instance of java.lang.Object :)
308 */
309
310 if ((this instanceof ArrayType) || (t instanceof ArrayType))
311 return Type.OBJECT;
312 // TODO: Is there a proof of OBJECT being the direct ancestor of every ArrayType?
313
314 if (((this instanceof ObjectType) && ((ObjectType) this).referencesInterface()) ||
315 ((t instanceof ObjectType) && ((ObjectType) t).referencesInterface()))
316 return Type.OBJECT;
317 // TODO: The above line is correct comparing to the vmspec2. But one could
318 // make class file verification a bit stronger here by using the notion of
319 // superinterfaces or even castability or assignment compatibility.
320
321
322 // this and t are ObjectTypes, see above.
323 ObjectType thiz = (ObjectType) this;
324 ObjectType other = (ObjectType) t;
325 JavaClass[] thiz_sups = Repository.getSuperClasses(thiz.getClassName());
326 JavaClass[] other_sups = Repository.getSuperClasses(other.getClassName());
327
328 if ((thiz_sups == null) || (other_sups == null)) {
329 return null;
330 }
331
332 // Waaahh...
333 JavaClass[] this_sups = new JavaClass[thiz_sups.length + 1];
334 JavaClass[] t_sups = new JavaClass[other_sups.length + 1];
335 System.arraycopy(thiz_sups, 0, this_sups, 1, thiz_sups.length);
336 System.arraycopy(other_sups, 0, t_sups, 1, other_sups.length);
337 this_sups[0] = Repository.lookupClass(thiz.getClassName());
338 t_sups[0] = Repository.lookupClass(other.getClassName());
339
340 for (int i = 0; i < t_sups.length; i++) {
341 for (int j = 0; j < this_sups.length; j++) {
342 if (this_sups[j].equals(t_sups[i])) return new ObjectType(this_sups[j].getClassName());
343 }
344 }
345
346 // Huh? Did you ask for Type.OBJECT's superclass??
347 return null;
348 }
349 }
This page was automatically generated by Maven