/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
implements ClassType
{
private boolean cachedSuperclass = false;
}
if(!cachedSuperclass) {
try {
} catch (JDWPException exc) {
throw exc.toJDIException();
}
/*
* If there is a superclass, cache its
* ClassType here. Otherwise,
* leave the cache reference null.
*/
superclass = sup;
}
cachedSuperclass = true;
}
return superclass;
}
if (interfaces == null) {
interfaces = getInterfaces();
}
return interfaces;
}
}
if (superclass != null) {
}
}
return all;
}
}
}
}
return subs;
}
public boolean isEnum() {
if (superclass != null &&
return true;
}
return false;
}
throws InvalidTypeException, ClassNotLoadedException {
// More validation specific to setting from a ClassType
throw new IllegalArgumentException(
"Must set non-static field through an instance");
}
try {
// validate and convert if necessary
try {
} catch (JDWPException exc) {
throw exc.toJDIException();
}
} catch (ClassNotLoadedException e) {
/*
* Since we got this exception,
* the field type must be a reference type. The value
* we're trying to set is null, but if the field's
* class has not yet been loaded through the enclosing
* class loader, then setting to null is essentially a
* no-op, and we should allow it without an exception.
*/
throw e;
}
}
}
final MethodImpl method,
final int options) {
new CommandSender() {
public PacketStream send() {
}
};
} else {
}
return stream;
}
final MethodImpl method,
final int options) {
new CommandSender() {
public PacketStream send() {
}
};
} else {
}
return stream;
}
throws InvalidTypeException,
try {
} catch (JDWPException exc) {
throw new IncompatibleThreadStateException();
} else {
throw exc.toJDIException();
}
}
/*
* There is an implict VM-wide suspend at the conclusion
* of a normal (non-single-threaded) method invoke
*/
vm.notifySuspend();
}
} else {
return ret.returnValue;
}
}
int options)
throws InvalidTypeException,
try {
} catch (JDWPException exc) {
throw new IncompatibleThreadStateException();
} else {
throw exc.toJDIException();
}
}
/*
* There is an implict VM-wide suspend at the conclusion
* of a normal (non-single-threaded) method invoke
*/
vm.notifySuspend();
}
} else {
}
}
!candidate.isAbstract()) {
break;
}
}
return method;
}
}
/*
* Avoid duplicate checking on each method by iterating through
* duplicate-free allInterfaces() rather than recursing
*/
}
return list;
}
if (superclass() != null) {
}
}
return inherited;
}
throws InvalidTypeException,
/*
* Method must be in this class or a superclass.
*/
if (!declType.isAssignableFrom(this)) {
throw new IllegalArgumentException("Invalid method");
}
/*
* Method must be a static and not a static initializer
*/
throw new IllegalArgumentException("Cannot invoke instance method on a class type");
} else if (method.isStaticInitializer()) {
throw new IllegalArgumentException("Cannot invoke static initializer");
}
}
throws InvalidTypeException,
/*
* Method must be in this class.
*/
throw new IllegalArgumentException("Invalid constructor");
}
/*
* Method must be a constructor
*/
if (!method.isConstructor()) {
throw new IllegalArgumentException("Cannot create instance with non-constructor");
}
}
/*
* Add methods from
* parent types first, so that the methods in this class will
* overwrite them in the hash table
*/
}
}
}
return true;
return true;
} else {
return true;
}
}
return false;
}
}
}
}