View Javadoc
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