--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jaxp/src/java.xml/share/classes/com/sun/org/apache/bcel/internal/generic/ReferenceType.java Sun Aug 17 15:51:56 2014 +0100
@@ -0,0 +1,352 @@
+/*
+ * reserved comment block
+ * DO NOT REMOVE OR ALTER!
+ */
+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 apache@apache.org.
+ *
+ * 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
+ * <http://www.apache.org/>.
+ */
+
+import com.sun.org.apache.bcel.internal.Constants;
+import com.sun.org.apache.bcel.internal.Repository;
+import com.sun.org.apache.bcel.internal.classfile.JavaClass;
+
+/**
+ * Super class for object and array types.
+ *
+ * @author <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
+ */
+public abstract class ReferenceType extends Type {
+ protected ReferenceType(byte t, String s) {
+ super(t, s);
+ }
+
+ /** Class is non-abstract but not instantiable from the outside
+ */
+ ReferenceType() {
+ super(Constants.T_OBJECT, "<null object>");
+ }
+
+ /**
+ * 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 <konst@cs.technion.ac.il> */
+
+ 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;
+ }
+}