com.sun.org.apache.bcel.internal.generic.ReferenceType Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jaxp-ri Show documentation
Show all versions of jaxp-ri Show documentation
Java API for XML Processing Reference Implementation
The newest version!
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can obtain
* a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
* or glassfish/bootstrap/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
* Sun designates this particular file as subject to the "Classpath" exception
* as provided by Sun in the GPL Version 2 section of the License file that
* accompanied this code. If applicable, add the following below the License
* Header, with the fields enclosed by brackets [] replaced by your own
* identifying information: "Portions Copyrighted [year]
* [name of copyright owner]"
*
* Contributor(s):
*
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package com.sun.org.apache.bcel.internal.generic;
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2001 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Apache" and "Apache Software Foundation" and
* "Apache BCEL" must not be used to endorse or promote products
* derived from this software without prior written permission. For
* written permission, please contact [email protected].
*
* 5. Products derived from this software may not be called "Apache",
* "Apache BCEL", nor may "Apache" appear in their name, without
* prior written permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* ");
}
/**
* Return true iff this type is castable to another type t as defined in
* the JVM specification. The case where this is Type.NULL is not
* defined (see the CHECKCAST definition in the JVM specification).
* However, because e.g. CHECKCAST doesn't throw a
* ClassCastException when casting a null reference to any Object,
* true is returned in this case.
*/
public boolean isCastableTo(Type t) {
if (this.equals(Type.NULL))
return true; // If this is ever changed in isAssignmentCompatible()
return isAssignmentCompatibleWith(t);
/* Yes, it's true: It's the same definition.
* See vmspec2 AASTORE / CHECKCAST definitions.
*/
}
/**
* Return true iff this is assignment compatible with another type t
* as defined in the JVM specification; see the AASTORE definition
* there.
*/
public boolean isAssignmentCompatibleWith(Type t) {
if (!(t instanceof ReferenceType))
return false;
ReferenceType T = (ReferenceType) t;
if (this.equals(Type.NULL))
return true; // This is not explicitely stated, but clear. Isn't it?
/* If this is a class type then
*/
if ((this instanceof ObjectType) && (((ObjectType) this).referencesClass())) {
/* If T is a class type, then this must be the same class as T,
or this must be a subclass of T;
*/
if ((T instanceof ObjectType) && (((ObjectType) T).referencesClass())) {
if (this.equals(T))
return true;
if (Repository.instanceOf(((ObjectType) this).getClassName(),
((ObjectType) T).getClassName()))
return true;
}
/* If T is an interface type, this must implement interface T.
*/
if ((T instanceof ObjectType) && (((ObjectType) T).referencesInterface())) {
if (Repository.implementationOf(((ObjectType) this).getClassName(),
((ObjectType) T).getClassName()))
return true;
}
}
/* If this is an interface type, then:
*/
if ((this instanceof ObjectType) && (((ObjectType) this).referencesInterface())) {
/* If T is a class type, then T must be Object (2.4.7).
*/
if ((T instanceof ObjectType) && (((ObjectType) T).referencesClass())) {
if (T.equals(Type.OBJECT)) return true;
}
/* If T is an interface type, then T must be the same interface
* as this or a superinterface of this (2.13.2).
*/
if ((T instanceof ObjectType) && (((ObjectType) T).referencesInterface())) {
if (this.equals(T)) return true;
if (Repository.implementationOf(((ObjectType) this).getClassName(),
((ObjectType) T).getClassName()))
return true;
}
}
/* If this is an array type, namely, the type SC[], that is, an
* array of components of type SC, then:
*/
if (this instanceof ArrayType) {
/* If T is a class type, then T must be Object (2.4.7).
*/
if ((T instanceof ObjectType) && (((ObjectType) T).referencesClass())) {
if (T.equals(Type.OBJECT)) return true;
}
/* If T is an array type TC[], that is, an array of components
* of type TC, then one of the following must be true:
*/
if (T instanceof ArrayType) {
/* TC and SC are the same primitive type (2.4.1).
*/
Type sc = ((ArrayType) this).getElementType();
Type tc = ((ArrayType) this).getElementType();
if (sc instanceof BasicType && tc instanceof BasicType && sc.equals(tc))
return true;
/* TC and SC are reference types (2.4.6), and type SC is
* assignable to TC by these runtime rules.
*/
if (tc instanceof ReferenceType && sc instanceof ReferenceType &&
((ReferenceType) sc).isAssignmentCompatibleWith((ReferenceType) tc))
return true;
}
/* If T is an interface type, T must be one of the interfaces implemented by arrays (2.15). */
// TODO: Check if this is still valid or find a way to dynamically find out which
// interfaces arrays implement. However, as of the JVM specification edition 2, there
// are at least two different pages where assignment compatibility is defined and
// on one of them "interfaces implemented by arrays" is exchanged with "'Cloneable' or
// 'java.io.Serializable'"
if ((T instanceof ObjectType) && (((ObjectType) T).referencesInterface())) {
for (int ii = 0; ii < Constants.INTERFACES_IMPLEMENTED_BY_ARRAYS.length; ii++) {
if (T.equals(new ObjectType(Constants.INTERFACES_IMPLEMENTED_BY_ARRAYS[ii]))) return true;
}
}
}
return false; // default.
}
/**
* This commutative operation returns the first common superclass (narrowest ReferenceType
* referencing a class, not an interface).
* If one of the types is a superclass of the other, the former is returned.
* If "this" is Type.NULL, then t is returned.
* If t is Type.NULL, then "this" is returned.
* If "this" equals t ['this.equals(t)'] "this" is returned.
* If "this" or t is an ArrayType, then Type.OBJECT is returned;
* unless their dimensions match. Then an ArrayType of the same
* number of dimensions is returned, with its basic type being the
* first common super class of the basic types of "this" and t.
* If "this" or t is a ReferenceType referencing an interface, then Type.OBJECT is returned.
* If not all of the two classes' superclasses cannot be found, "null" is returned.
* See the JVM specification edition 2, "4.9.2 The Bytecode Verifier".
*/
public ReferenceType getFirstCommonSuperclass(ReferenceType t) {
if (this.equals(Type.NULL)) return t;
if (t.equals(Type.NULL)) return this;
if (this.equals(t)) return this;
/*
* TODO: Above sounds a little arbitrary. On the other hand, there is
* no object referenced by Type.NULL so we can also say all the objects
* referenced by Type.NULL were derived from java.lang.Object.
* However, the Java Language's "instanceof" operator proves us wrong:
* "null" is not referring to an instance of java.lang.Object :)
*/
/* This code is from a bug report by Konstantin Shagin */
if ((this instanceof ArrayType) && (t instanceof ArrayType)) {
ArrayType arrType1 = (ArrayType) this;
ArrayType arrType2 = (ArrayType) t;
if (
(arrType1.getDimensions() == arrType2.getDimensions()) &&
arrType1.getBasicType() instanceof ObjectType &&
arrType2.getBasicType() instanceof ObjectType) {
return new ArrayType(
((ObjectType) arrType1.getBasicType()).getFirstCommonSuperclass((ObjectType) arrType2.getBasicType()),
arrType1.getDimensions()
);
}
}
if ((this instanceof ArrayType) || (t instanceof ArrayType))
return Type.OBJECT;
// TODO: Is there a proof of OBJECT being the direct ancestor of every ArrayType?
if (((this instanceof ObjectType) && ((ObjectType) this).referencesInterface()) ||
((t instanceof ObjectType) && ((ObjectType) t).referencesInterface()))
return Type.OBJECT;
// TODO: The above line is correct comparing to the vmspec2. But one could
// make class file verification a bit stronger here by using the notion of
// superinterfaces or even castability or assignment compatibility.
// this and t are ObjectTypes, see above.
ObjectType thiz = (ObjectType) this;
ObjectType other = (ObjectType) t;
JavaClass[] thiz_sups = Repository.getSuperClasses(thiz.getClassName());
JavaClass[] other_sups = Repository.getSuperClasses(other.getClassName());
if ((thiz_sups == null) || (other_sups == null)) {
return null;
}
// Waaahh...
JavaClass[] this_sups = new JavaClass[thiz_sups.length + 1];
JavaClass[] t_sups = new JavaClass[other_sups.length + 1];
System.arraycopy(thiz_sups, 0, this_sups, 1, thiz_sups.length);
System.arraycopy(other_sups, 0, t_sups, 1, other_sups.length);
this_sups[0] = Repository.lookupClass(thiz.getClassName());
t_sups[0] = Repository.lookupClass(other.getClassName());
for (int i = 0; i < t_sups.length; i++) {
for (int j = 0; j < this_sups.length; j++) {
if (this_sups[j].equals(t_sups[i])) return new ObjectType(this_sups[j].getClassName());
}
}
// Huh? Did you ask for Type.OBJECT's superclass??
return null;
}
/**
* This commutative operation returns the first common superclass (narrowest ReferenceType
* referencing a class, not an interface).
* If one of the types is a superclass of the other, the former is returned.
* If "this" is Type.NULL, then t is returned.
* If t is Type.NULL, then "this" is returned.
* If "this" equals t ['this.equals(t)'] "this" is returned.
* If "this" or t is an ArrayType, then Type.OBJECT is returned.
* If "this" or t is a ReferenceType referencing an interface, then Type.OBJECT is returned.
* If not all of the two classes' superclasses cannot be found, "null" is returned.
* See the JVM specification edition 2, "4.9.2 The Bytecode Verifier".
*
* @deprecated use getFirstCommonSuperclass(ReferenceType t) which has
* slightly changed semantics.
*/
public ReferenceType firstCommonSuperclass(ReferenceType t) {
if (this.equals(Type.NULL)) return t;
if (t.equals(Type.NULL)) return this;
if (this.equals(t)) return this;
/*
* TODO: Above sounds a little arbitrary. On the other hand, there is
* no object referenced by Type.NULL so we can also say all the objects
* referenced by Type.NULL were derived from java.lang.Object.
* However, the Java Language's "instanceof" operator proves us wrong:
* "null" is not referring to an instance of java.lang.Object :)
*/
if ((this instanceof ArrayType) || (t instanceof ArrayType))
return Type.OBJECT;
// TODO: Is there a proof of OBJECT being the direct ancestor of every ArrayType?
if (((this instanceof ObjectType) && ((ObjectType) this).referencesInterface()) ||
((t instanceof ObjectType) && ((ObjectType) t).referencesInterface()))
return Type.OBJECT;
// TODO: The above line is correct comparing to the vmspec2. But one could
// make class file verification a bit stronger here by using the notion of
// superinterfaces or even castability or assignment compatibility.
// this and t are ObjectTypes, see above.
ObjectType thiz = (ObjectType) this;
ObjectType other = (ObjectType) t;
JavaClass[] thiz_sups = Repository.getSuperClasses(thiz.getClassName());
JavaClass[] other_sups = Repository.getSuperClasses(other.getClassName());
if ((thiz_sups == null) || (other_sups == null)) {
return null;
}
// Waaahh...
JavaClass[] this_sups = new JavaClass[thiz_sups.length + 1];
JavaClass[] t_sups = new JavaClass[other_sups.length + 1];
System.arraycopy(thiz_sups, 0, this_sups, 1, thiz_sups.length);
System.arraycopy(other_sups, 0, t_sups, 1, other_sups.length);
this_sups[0] = Repository.lookupClass(thiz.getClassName());
t_sups[0] = Repository.lookupClass(other.getClassName());
for (int i = 0; i < t_sups.length; i++) {
for (int j = 0; j < this_sups.length; j++) {
if (this_sups[j].equals(t_sups[i])) return new ObjectType(this_sups[j].getClassName());
}
}
// Huh? Did you ask for Type.OBJECT's superclass??
return null;
}
}