| /* |
| * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * 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. |
| */ |
| |
| package com.sun.tools.jdi; |
| |
| import com.sun.jdi.*; |
| |
| import java.util.*; |
| import java.lang.ref.SoftReference; |
| |
| public abstract class ReferenceTypeImpl extends TypeImpl |
| implements ReferenceType { |
| protected long ref; |
| private String signature = null; |
| private String genericSignature = null; |
| private boolean genericSignatureGotten = false; |
| private String baseSourceName = null; |
| private String baseSourceDir = null; |
| private String baseSourcePath = null; |
| protected int modifiers = -1; |
| private SoftReference<List<Field>> fieldsRef = null; |
| private SoftReference<List<Method>> methodsRef = null; |
| private SoftReference<SDE> sdeRef = null; |
| |
| private boolean isClassLoaderCached = false; |
| private ClassLoaderReference classLoader = null; |
| private ClassObjectReference classObject = null; |
| |
| private int status = 0; |
| private boolean isPrepared = false; |
| |
| |
| private boolean versionNumberGotten = false; |
| private int majorVersion; |
| private int minorVersion; |
| |
| private boolean constantPoolInfoGotten = false; |
| private int constanPoolCount; |
| private byte[] constantPoolBytes; |
| private SoftReference<byte[]> constantPoolBytesRef = null; |
| |
| /* to mark a SourceFile request that returned a genuine JDWP.Error.ABSENT_INFORMATION */ |
| private static final String ABSENT_BASE_SOURCE_NAME = "**ABSENT_BASE_SOURCE_NAME**"; |
| |
| /* to mark when no info available */ |
| static final SDE NO_SDE_INFO_MARK = new SDE(); |
| |
| // bits set when initialization was attempted (succeeded or failed) |
| private static final int INITIALIZED_OR_FAILED = |
| JDWP.ClassStatus.INITIALIZED | JDWP.ClassStatus.ERROR; |
| |
| |
| protected ReferenceTypeImpl(VirtualMachine aVm, long aRef) { |
| super(aVm); |
| ref = aRef; |
| genericSignatureGotten = false; |
| } |
| |
| void noticeRedefineClass() { |
| //Invalidate information previously fetched and cached. |
| //These will be refreshed later on demand. |
| baseSourceName = null; |
| baseSourcePath = null; |
| modifiers = -1; |
| fieldsRef = null; |
| methodsRef = null; |
| sdeRef = null; |
| versionNumberGotten = false; |
| constantPoolInfoGotten = false; |
| } |
| |
| Method getMethodMirror(long ref) { |
| if (ref == 0) { |
| // obsolete method |
| return new ObsoleteMethodImpl(vm, this); |
| } |
| // Fetch all methods for the class, check performance impact |
| // Needs no synchronization now, since methods() returns |
| // unmodifiable local data |
| Iterator<Method> it = methods().iterator(); |
| while (it.hasNext()) { |
| MethodImpl method = (MethodImpl)it.next(); |
| if (method.ref() == ref) { |
| return method; |
| } |
| } |
| throw new IllegalArgumentException("Invalid method id: " + ref); |
| } |
| |
| Field getFieldMirror(long ref) { |
| // Fetch all fields for the class, check performance impact |
| // Needs no synchronization now, since fields() returns |
| // unmodifiable local data |
| Iterator<Field>it = fields().iterator(); |
| while (it.hasNext()) { |
| FieldImpl field = (FieldImpl)it.next(); |
| if (field.ref() == ref) { |
| return field; |
| } |
| } |
| throw new IllegalArgumentException("Invalid field id: " + ref); |
| } |
| |
| public boolean equals(Object obj) { |
| if ((obj != null) && (obj instanceof ReferenceTypeImpl)) { |
| ReferenceTypeImpl other = (ReferenceTypeImpl)obj; |
| return (ref() == other.ref()) && |
| (vm.equals(other.virtualMachine())); |
| } else { |
| return false; |
| } |
| } |
| |
| public int hashCode() { |
| return(int)ref(); |
| } |
| |
| public int compareTo(ReferenceType object) { |
| /* |
| * Note that it is critical that compareTo() == 0 |
| * implies that equals() == true. Otherwise, TreeSet |
| * will collapse classes. |
| * |
| * (Classes of the same name loaded by different class loaders |
| * or in different VMs must not return 0). |
| */ |
| ReferenceTypeImpl other = (ReferenceTypeImpl)object; |
| int comp = name().compareTo(other.name()); |
| if (comp == 0) { |
| long rf1 = ref(); |
| long rf2 = other.ref(); |
| // optimize for typical case: refs equal and VMs equal |
| if (rf1 == rf2) { |
| // sequenceNumbers are always positive |
| comp = vm.sequenceNumber - |
| ((VirtualMachineImpl)(other.virtualMachine())).sequenceNumber; |
| } else { |
| comp = (rf1 < rf2)? -1 : 1; |
| } |
| } |
| return comp; |
| } |
| |
| public String signature() { |
| if (signature == null) { |
| // Does not need synchronization, since worst-case |
| // static info is fetched twice |
| if (vm.canGet1_5LanguageFeatures()) { |
| /* |
| * we might as well get both the signature and the |
| * generic signature. |
| */ |
| genericSignature(); |
| } else { |
| try { |
| signature = JDWP.ReferenceType.Signature. |
| process(vm, this).signature; |
| } catch (JDWPException exc) { |
| throw exc.toJDIException(); |
| } |
| } |
| } |
| return signature; |
| } |
| |
| public String genericSignature() { |
| // This gets both the signature and the generic signature |
| if (vm.canGet1_5LanguageFeatures() && !genericSignatureGotten) { |
| // Does not need synchronization, since worst-case |
| // static info is fetched twice |
| JDWP.ReferenceType.SignatureWithGeneric result; |
| try { |
| result = JDWP.ReferenceType.SignatureWithGeneric. |
| process(vm, this); |
| } catch (JDWPException exc) { |
| throw exc.toJDIException(); |
| } |
| signature = result.signature; |
| setGenericSignature(result.genericSignature); |
| } |
| return genericSignature; |
| } |
| |
| public ClassLoaderReference classLoader() { |
| if (!isClassLoaderCached) { |
| // Does not need synchronization, since worst-case |
| // static info is fetched twice |
| try { |
| classLoader = (ClassLoaderReference) |
| JDWP.ReferenceType.ClassLoader. |
| process(vm, this).classLoader; |
| isClassLoaderCached = true; |
| } catch (JDWPException exc) { |
| throw exc.toJDIException(); |
| } |
| } |
| return classLoader; |
| } |
| |
| public boolean isPublic() { |
| if (modifiers == -1) |
| getModifiers(); |
| |
| return((modifiers & VMModifiers.PUBLIC) > 0); |
| } |
| |
| public boolean isProtected() { |
| if (modifiers == -1) |
| getModifiers(); |
| |
| return((modifiers & VMModifiers.PROTECTED) > 0); |
| } |
| |
| public boolean isPrivate() { |
| if (modifiers == -1) |
| getModifiers(); |
| |
| return((modifiers & VMModifiers.PRIVATE) > 0); |
| } |
| |
| public boolean isPackagePrivate() { |
| return !isPublic() && !isPrivate() && !isProtected(); |
| } |
| |
| public boolean isAbstract() { |
| if (modifiers == -1) |
| getModifiers(); |
| |
| return((modifiers & VMModifiers.ABSTRACT) > 0); |
| } |
| |
| public boolean isFinal() { |
| if (modifiers == -1) |
| getModifiers(); |
| |
| return((modifiers & VMModifiers.FINAL) > 0); |
| } |
| |
| public boolean isStatic() { |
| if (modifiers == -1) |
| getModifiers(); |
| |
| return((modifiers & VMModifiers.STATIC) > 0); |
| } |
| |
| public boolean isPrepared() { |
| // This ref type may have been prepared before we were getting |
| // events, so get it once. After that, |
| // this status flag is updated through the ClassPrepareEvent, |
| // there is no need for the expense of a JDWP query. |
| if (status == 0) { |
| updateStatus(); |
| } |
| return isPrepared; |
| } |
| |
| public boolean isVerified() { |
| // Once true, it never resets, so we don't need to update |
| if ((status & JDWP.ClassStatus.VERIFIED) == 0) { |
| updateStatus(); |
| } |
| return (status & JDWP.ClassStatus.VERIFIED) != 0; |
| } |
| |
| public boolean isInitialized() { |
| // Once initialization succeeds or fails, it never resets, |
| // so we don't need to update |
| if ((status & INITIALIZED_OR_FAILED) == 0) { |
| updateStatus(); |
| } |
| return (status & JDWP.ClassStatus.INITIALIZED) != 0; |
| } |
| |
| public boolean failedToInitialize() { |
| // Once initialization succeeds or fails, it never resets, |
| // so we don't need to update |
| if ((status & INITIALIZED_OR_FAILED) == 0) { |
| updateStatus(); |
| } |
| return (status & JDWP.ClassStatus.ERROR) != 0; |
| } |
| |
| public List<Field> fields() { |
| List<Field> fields = (fieldsRef == null) ? null : fieldsRef.get(); |
| if (fields == null) { |
| if (vm.canGet1_5LanguageFeatures()) { |
| JDWP.ReferenceType.FieldsWithGeneric.FieldInfo[] jdwpFields; |
| try { |
| jdwpFields = JDWP.ReferenceType.FieldsWithGeneric.process(vm, this).declared; |
| } catch (JDWPException exc) { |
| throw exc.toJDIException(); |
| } |
| fields = new ArrayList<Field>(jdwpFields.length); |
| for (int i=0; i<jdwpFields.length; i++) { |
| JDWP.ReferenceType.FieldsWithGeneric.FieldInfo fi |
| = jdwpFields[i]; |
| |
| Field field = new FieldImpl(vm, this, fi.fieldID, |
| fi.name, fi.signature, |
| fi.genericSignature, |
| fi.modBits); |
| fields.add(field); |
| } |
| } else { |
| JDWP.ReferenceType.Fields.FieldInfo[] jdwpFields; |
| try { |
| jdwpFields = JDWP.ReferenceType.Fields. |
| process(vm, this).declared; |
| } catch (JDWPException exc) { |
| throw exc.toJDIException(); |
| } |
| fields = new ArrayList<Field>(jdwpFields.length); |
| for (int i=0; i<jdwpFields.length; i++) { |
| JDWP.ReferenceType.Fields.FieldInfo fi = jdwpFields[i]; |
| |
| Field field = new FieldImpl(vm, this, fi.fieldID, |
| fi.name, fi.signature, |
| null, |
| fi.modBits); |
| fields.add(field); |
| } |
| } |
| |
| fields = Collections.unmodifiableList(fields); |
| fieldsRef = new SoftReference<List<Field>>(fields); |
| } |
| return fields; |
| } |
| |
| abstract List<? extends ReferenceType> inheritedTypes(); |
| |
| void addVisibleFields(List<Field> visibleList, Map<String, Field> visibleTable, List<String> ambiguousNames) { |
| for (Field field : visibleFields()) { |
| String name = field.name(); |
| if (!ambiguousNames.contains(name)) { |
| Field duplicate = visibleTable.get(name); |
| if (duplicate == null) { |
| visibleList.add(field); |
| visibleTable.put(name, field); |
| } else if (!field.equals(duplicate)) { |
| ambiguousNames.add(name); |
| visibleTable.remove(name); |
| visibleList.remove(duplicate); |
| } else { |
| // identical field from two branches; do nothing |
| } |
| } |
| } |
| } |
| |
| public List<Field> visibleFields() { |
| /* |
| * Maintain two different collections of visible fields. The |
| * list maintains a reasonable order for return. The |
| * hash map provides an efficient way to lookup visible fields |
| * by name, important for finding hidden or ambiguous fields. |
| */ |
| List<Field> visibleList = new ArrayList<Field>(); |
| Map<String, Field> visibleTable = new HashMap<String, Field>(); |
| |
| /* Track fields removed from above collection due to ambiguity */ |
| List<String> ambiguousNames = new ArrayList<String>(); |
| |
| /* Add inherited, visible fields */ |
| List<? extends ReferenceType> types = inheritedTypes(); |
| Iterator<? extends ReferenceType> iter = types.iterator(); |
| while (iter.hasNext()) { |
| /* |
| * TO DO: Be defensive and check for cyclic interface inheritance |
| */ |
| ReferenceTypeImpl type = (ReferenceTypeImpl)iter.next(); |
| type.addVisibleFields(visibleList, visibleTable, ambiguousNames); |
| } |
| |
| /* |
| * Insert fields from this type, removing any inherited fields they |
| * hide. |
| */ |
| List<Field> retList = new ArrayList<Field>(fields()); |
| for (Field field : retList) { |
| Field hidden = visibleTable.get(field.name()); |
| if (hidden != null) { |
| visibleList.remove(hidden); |
| } |
| } |
| retList.addAll(visibleList); |
| return retList; |
| } |
| |
| void addAllFields(List<Field> fieldList, Set<ReferenceType> typeSet) { |
| /* Continue the recursion only if this type is new */ |
| if (!typeSet.contains(this)) { |
| typeSet.add((ReferenceType)this); |
| |
| /* Add local fields */ |
| fieldList.addAll(fields()); |
| |
| /* Add inherited fields */ |
| List<? extends ReferenceType> types = inheritedTypes(); |
| Iterator<? extends ReferenceType> iter = types.iterator(); |
| while (iter.hasNext()) { |
| ReferenceTypeImpl type = (ReferenceTypeImpl)iter.next(); |
| type.addAllFields(fieldList, typeSet); |
| } |
| } |
| } |
| public List<Field> allFields() { |
| List<Field> fieldList = new ArrayList<Field>(); |
| Set<ReferenceType> typeSet = new HashSet<ReferenceType>(); |
| addAllFields(fieldList, typeSet); |
| return fieldList; |
| } |
| |
| public Field fieldByName(String fieldName) { |
| List<Field> searchList = visibleFields(); |
| |
| for (int i=0; i<searchList.size(); i++) { |
| Field f = searchList.get(i); |
| |
| if (f.name().equals(fieldName)) { |
| return f; |
| } |
| } |
| //throw new NoSuchFieldException("Field '" + fieldName + "' not found in " + name()); |
| return null; |
| } |
| |
| public List<Method> methods() { |
| List<Method> methods = (methodsRef == null) ? null : methodsRef.get(); |
| if (methods == null) { |
| if (!vm.canGet1_5LanguageFeatures()) { |
| methods = methods1_4(); |
| } else { |
| JDWP.ReferenceType.MethodsWithGeneric.MethodInfo[] declared; |
| try { |
| declared = JDWP.ReferenceType.MethodsWithGeneric. |
| process(vm, this).declared; |
| } catch (JDWPException exc) { |
| throw exc.toJDIException(); |
| } |
| methods = new ArrayList<Method>(declared.length); |
| for (int i=0; i<declared.length; i++) { |
| JDWP.ReferenceType.MethodsWithGeneric.MethodInfo |
| mi = declared[i]; |
| |
| Method method = MethodImpl.createMethodImpl(vm, this, |
| mi.methodID, |
| mi.name, mi.signature, |
| mi.genericSignature, |
| mi.modBits); |
| methods.add(method); |
| } |
| } |
| methods = Collections.unmodifiableList(methods); |
| methodsRef = new SoftReference<List<Method>>(methods); |
| } |
| return methods; |
| } |
| |
| private List<Method> methods1_4() { |
| List<Method> methods; |
| JDWP.ReferenceType.Methods.MethodInfo[] declared; |
| try { |
| declared = JDWP.ReferenceType.Methods. |
| process(vm, this).declared; |
| } catch (JDWPException exc) { |
| throw exc.toJDIException(); |
| } |
| methods = new ArrayList<Method>(declared.length); |
| for (int i=0; i<declared.length; i++) { |
| JDWP.ReferenceType.Methods.MethodInfo mi = declared[i]; |
| |
| Method method = MethodImpl.createMethodImpl(vm, this, |
| mi.methodID, |
| mi.name, mi.signature, |
| null, |
| mi.modBits); |
| methods.add(method); |
| } |
| return methods; |
| } |
| |
| /* |
| * Utility method used by subclasses to build lists of visible |
| * methods. |
| */ |
| void addToMethodMap(Map<String, Method> methodMap, List<Method> methodList) { |
| for (Method method : methodList) |
| methodMap.put(method.name().concat(method.signature()), method); |
| } |
| |
| abstract void addVisibleMethods(Map<String, Method> methodMap, Set<InterfaceType> seenInterfaces); |
| |
| public List<Method> visibleMethods() { |
| /* |
| * Build a collection of all visible methods. The hash |
| * map allows us to do this efficiently by keying on the |
| * concatenation of name and signature. |
| */ |
| Map<String, Method> map = new HashMap<String, Method>(); |
| addVisibleMethods(map, new HashSet<InterfaceType>()); |
| |
| /* |
| * ... but the hash map destroys order. Methods should be |
| * returned in a sensible order, as they are in allMethods(). |
| * So, start over with allMethods() and use the hash map |
| * to filter that ordered collection. |
| */ |
| List<Method> list = allMethods(); |
| list.retainAll(map.values()); |
| return list; |
| } |
| |
| abstract public List<Method> allMethods(); |
| |
| public List<Method> methodsByName(String name) { |
| List<Method> methods = visibleMethods(); |
| ArrayList<Method> retList = new ArrayList<Method>(methods.size()); |
| for (Method candidate : methods) { |
| if (candidate.name().equals(name)) { |
| retList.add(candidate); |
| } |
| } |
| retList.trimToSize(); |
| return retList; |
| } |
| |
| public List<Method> methodsByName(String name, String signature) { |
| List<Method> methods = visibleMethods(); |
| ArrayList<Method> retList = new ArrayList<Method>(methods.size()); |
| for (Method candidate : methods) { |
| if (candidate.name().equals(name) && |
| candidate.signature().equals(signature)) { |
| retList.add(candidate); |
| } |
| } |
| retList.trimToSize(); |
| return retList; |
| } |
| |
| List<InterfaceType> getInterfaces() { |
| InterfaceTypeImpl[] intfs; |
| try { |
| intfs = JDWP.ReferenceType.Interfaces. |
| process(vm, this).interfaces; |
| } catch (JDWPException exc) { |
| throw exc.toJDIException(); |
| } |
| return Arrays.asList((InterfaceType[])intfs); |
| } |
| |
| public List<ReferenceType> nestedTypes() { |
| List<ReferenceType> all = vm.allClasses(); |
| List<ReferenceType> nested = new ArrayList<ReferenceType>(); |
| String outername = name(); |
| int outerlen = outername.length(); |
| Iterator<ReferenceType> iter = all.iterator(); |
| while (iter.hasNext()) { |
| ReferenceType refType = iter.next(); |
| String name = refType.name(); |
| int len = name.length(); |
| /* The separator is historically '$' but could also be '#' */ |
| if ( len > outerlen && name.startsWith(outername) ) { |
| char c = name.charAt(outerlen); |
| if ( c =='$' || c== '#' ) { |
| nested.add(refType); |
| } |
| } |
| } |
| return nested; |
| } |
| |
| public Value getValue(Field sig) { |
| List<Field> list = new ArrayList<Field>(1); |
| list.add(sig); |
| Map<Field, Value> map = getValues(list); |
| return map.get(sig); |
| } |
| |
| |
| void validateFieldAccess(Field field) { |
| /* |
| * Field must be in this object's class, a superclass, or |
| * implemented interface |
| */ |
| ReferenceTypeImpl declType = (ReferenceTypeImpl)field.declaringType(); |
| if (!declType.isAssignableFrom(this)) { |
| throw new IllegalArgumentException("Invalid field"); |
| } |
| } |
| |
| void validateFieldSet(Field field) { |
| validateFieldAccess(field); |
| if (field.isFinal()) { |
| throw new IllegalArgumentException("Cannot set value of final field"); |
| } |
| } |
| |
| /** |
| * Returns a map of field values |
| */ |
| public Map<Field,Value> getValues(List<? extends Field> theFields) { |
| validateMirrors(theFields); |
| |
| int size = theFields.size(); |
| JDWP.ReferenceType.GetValues.Field[] queryFields = |
| new JDWP.ReferenceType.GetValues.Field[size]; |
| |
| for (int i=0; i<size; i++) { |
| FieldImpl field = (FieldImpl)theFields.get(i); |
| |
| validateFieldAccess(field); |
| |
| // Do more validation specific to ReferenceType field getting |
| if (!field.isStatic()) { |
| throw new IllegalArgumentException( |
| "Attempt to use non-static field with ReferenceType"); |
| } |
| queryFields[i] = new JDWP.ReferenceType.GetValues.Field( |
| field.ref()); |
| } |
| |
| Map<Field, Value> map = new HashMap<Field, Value>(size); |
| |
| ValueImpl[] values; |
| try { |
| values = JDWP.ReferenceType.GetValues. |
| process(vm, this, queryFields).values; |
| } catch (JDWPException exc) { |
| throw exc.toJDIException(); |
| } |
| |
| if (size != values.length) { |
| throw new InternalException( |
| "Wrong number of values returned from target VM"); |
| } |
| for (int i=0; i<size; i++) { |
| FieldImpl field = (FieldImpl)theFields.get(i); |
| map.put(field, values[i]); |
| } |
| |
| return map; |
| } |
| |
| public ClassObjectReference classObject() { |
| if (classObject == null) { |
| // Are classObjects unique for an Object, or |
| // created each time? Is this spec'ed? |
| synchronized(this) { |
| if (classObject == null) { |
| try { |
| classObject = JDWP.ReferenceType.ClassObject. |
| process(vm, this).classObject; |
| } catch (JDWPException exc) { |
| throw exc.toJDIException(); |
| } |
| } |
| } |
| } |
| return classObject; |
| } |
| |
| SDE.Stratum stratum(String stratumID) { |
| SDE sde = sourceDebugExtensionInfo(); |
| if (!sde.isValid()) { |
| sde = NO_SDE_INFO_MARK; |
| } |
| return sde.stratum(stratumID); |
| } |
| |
| public String sourceName() throws AbsentInformationException { |
| return sourceNames(vm.getDefaultStratum()).get(0); |
| } |
| |
| public List<String> sourceNames(String stratumID) |
| throws AbsentInformationException { |
| SDE.Stratum stratum = stratum(stratumID); |
| if (stratum.isJava()) { |
| List<String> result = new ArrayList<String>(1); |
| result.add(baseSourceName()); |
| return result; |
| } |
| return stratum.sourceNames(this); |
| } |
| |
| public List<String> sourcePaths(String stratumID) |
| throws AbsentInformationException { |
| SDE.Stratum stratum = stratum(stratumID); |
| if (stratum.isJava()) { |
| List<String> result = new ArrayList<String>(1); |
| result.add(baseSourceDir() + baseSourceName()); |
| return result; |
| } |
| return stratum.sourcePaths(this); |
| } |
| |
| String baseSourceName() throws AbsentInformationException { |
| String bsn = baseSourceName; |
| if (bsn == null) { |
| // Does not need synchronization, since worst-case |
| // static info is fetched twice |
| try { |
| bsn = JDWP.ReferenceType.SourceFile. |
| process(vm, this).sourceFile; |
| } catch (JDWPException exc) { |
| if (exc.errorCode() == JDWP.Error.ABSENT_INFORMATION) { |
| bsn = ABSENT_BASE_SOURCE_NAME; |
| } else { |
| throw exc.toJDIException(); |
| } |
| } |
| baseSourceName = bsn; |
| } |
| if (bsn == ABSENT_BASE_SOURCE_NAME) { |
| throw new AbsentInformationException(); |
| } |
| return bsn; |
| } |
| |
| String baseSourcePath() throws AbsentInformationException { |
| String bsp = baseSourcePath; |
| if (bsp == null) { |
| bsp = baseSourceDir() + baseSourceName(); |
| baseSourcePath = bsp; |
| } |
| return bsp; |
| } |
| |
| String baseSourceDir() { |
| if (baseSourceDir == null) { |
| String typeName = name(); |
| StringBuffer sb = new StringBuffer(typeName.length() + 10); |
| int index = 0; |
| int nextIndex; |
| |
| while ((nextIndex = typeName.indexOf('.', index)) > 0) { |
| sb.append(typeName.substring(index, nextIndex)); |
| sb.append(java.io.File.separatorChar); |
| index = nextIndex + 1; |
| } |
| baseSourceDir = sb.toString(); |
| } |
| return baseSourceDir; |
| } |
| |
| public String sourceDebugExtension() |
| throws AbsentInformationException { |
| if (!vm.canGetSourceDebugExtension()) { |
| throw new UnsupportedOperationException(); |
| } |
| SDE sde = sourceDebugExtensionInfo(); |
| if (sde == NO_SDE_INFO_MARK) { |
| throw new AbsentInformationException(); |
| } |
| return sde.sourceDebugExtension; |
| } |
| |
| private SDE sourceDebugExtensionInfo() { |
| if (!vm.canGetSourceDebugExtension()) { |
| return NO_SDE_INFO_MARK; |
| } |
| SDE sde = (sdeRef == null) ? null : sdeRef.get(); |
| if (sde == null) { |
| String extension = null; |
| try { |
| extension = JDWP.ReferenceType.SourceDebugExtension. |
| process(vm, this).extension; |
| } catch (JDWPException exc) { |
| if (exc.errorCode() != JDWP.Error.ABSENT_INFORMATION) { |
| sdeRef = new SoftReference<SDE>(NO_SDE_INFO_MARK); |
| throw exc.toJDIException(); |
| } |
| } |
| if (extension == null) { |
| sde = NO_SDE_INFO_MARK; |
| } else { |
| sde = new SDE(extension); |
| } |
| sdeRef = new SoftReference<SDE>(sde); |
| } |
| return sde; |
| } |
| |
| public List<String> availableStrata() { |
| SDE sde = sourceDebugExtensionInfo(); |
| if (sde.isValid()) { |
| return sde.availableStrata(); |
| } else { |
| List<String> strata = new ArrayList<String>(); |
| strata.add(SDE.BASE_STRATUM_NAME); |
| return strata; |
| } |
| } |
| |
| /** |
| * Always returns non-null stratumID |
| */ |
| public String defaultStratum() { |
| SDE sdei = sourceDebugExtensionInfo(); |
| if (sdei.isValid()) { |
| return sdei.defaultStratumId; |
| } else { |
| return SDE.BASE_STRATUM_NAME; |
| } |
| } |
| |
| public int modifiers() { |
| if (modifiers == -1) |
| getModifiers(); |
| |
| return modifiers; |
| } |
| |
| public List<Location> allLineLocations() |
| throws AbsentInformationException { |
| return allLineLocations(vm.getDefaultStratum(), null); |
| } |
| |
| public List<Location> allLineLocations(String stratumID, String sourceName) |
| throws AbsentInformationException { |
| boolean someAbsent = false; // A method that should have info, didn't |
| SDE.Stratum stratum = stratum(stratumID); |
| List<Location> list = new ArrayList<Location>(); // location list |
| |
| for (Iterator<Method> iter = methods().iterator(); iter.hasNext(); ) { |
| MethodImpl method = (MethodImpl)iter.next(); |
| try { |
| list.addAll( |
| method.allLineLocations(stratum, sourceName)); |
| } catch(AbsentInformationException exc) { |
| someAbsent = true; |
| } |
| } |
| |
| // If we retrieved no line info, and at least one of the methods |
| // should have had some (as determined by an |
| // AbsentInformationException being thrown) then we rethrow |
| // the AbsentInformationException. |
| if (someAbsent && list.size() == 0) { |
| throw new AbsentInformationException(); |
| } |
| return list; |
| } |
| |
| public List<Location> locationsOfLine(int lineNumber) |
| throws AbsentInformationException { |
| return locationsOfLine(vm.getDefaultStratum(), |
| null, |
| lineNumber); |
| } |
| |
| public List<Location> locationsOfLine(String stratumID, |
| String sourceName, |
| int lineNumber) |
| throws AbsentInformationException { |
| // A method that should have info, didn't |
| boolean someAbsent = false; |
| // A method that should have info, did |
| boolean somePresent = false; |
| List<Method> methods = methods(); |
| SDE.Stratum stratum = stratum(stratumID); |
| |
| List<Location> list = new ArrayList<Location>(); |
| |
| Iterator<Method> iter = methods.iterator(); |
| while(iter.hasNext()) { |
| MethodImpl method = (MethodImpl)iter.next(); |
| // eliminate native and abstract to eliminate |
| // false positives |
| if (!method.isAbstract() && |
| !method.isNative()) { |
| try { |
| list.addAll( |
| method.locationsOfLine(stratum, |
| sourceName, |
| lineNumber)); |
| somePresent = true; |
| } catch(AbsentInformationException exc) { |
| someAbsent = true; |
| } |
| } |
| } |
| if (someAbsent && !somePresent) { |
| throw new AbsentInformationException(); |
| } |
| return list; |
| } |
| |
| public List<ObjectReference> instances(long maxInstances) { |
| if (!vm.canGetInstanceInfo()) { |
| throw new UnsupportedOperationException( |
| "target does not support getting instances"); |
| } |
| |
| if (maxInstances < 0) { |
| throw new IllegalArgumentException("maxInstances is less than zero: " |
| + maxInstances); |
| } |
| int intMax = (maxInstances > Integer.MAX_VALUE)? |
| Integer.MAX_VALUE: (int)maxInstances; |
| // JDWP can't currently handle more than this (in mustang) |
| |
| try { |
| return Arrays.asList( |
| (ObjectReference[])JDWP.ReferenceType.Instances. |
| process(vm, this, intMax).instances); |
| } catch (JDWPException exc) { |
| throw exc.toJDIException(); |
| } |
| } |
| |
| private void getClassFileVersion() { |
| if (!vm.canGetClassFileVersion()) { |
| throw new UnsupportedOperationException(); |
| } |
| JDWP.ReferenceType.ClassFileVersion classFileVersion; |
| if (versionNumberGotten) { |
| return; |
| } else { |
| try { |
| classFileVersion = JDWP.ReferenceType.ClassFileVersion.process(vm, this); |
| } catch (JDWPException exc) { |
| if (exc.errorCode() == JDWP.Error.ABSENT_INFORMATION) { |
| majorVersion = 0; |
| minorVersion = 0; |
| versionNumberGotten = true; |
| return; |
| } else { |
| throw exc.toJDIException(); |
| } |
| } |
| majorVersion = classFileVersion.majorVersion; |
| minorVersion = classFileVersion.minorVersion; |
| versionNumberGotten = true; |
| } |
| } |
| |
| public int majorVersion() { |
| try { |
| getClassFileVersion(); |
| } catch (RuntimeException exc) { |
| throw exc; |
| } |
| return majorVersion; |
| } |
| |
| public int minorVersion() { |
| try { |
| getClassFileVersion(); |
| } catch (RuntimeException exc) { |
| throw exc; |
| } |
| return minorVersion; |
| } |
| |
| private byte[] getConstantPoolInfo() { |
| JDWP.ReferenceType.ConstantPool jdwpCPool; |
| if (!vm.canGetConstantPool()) { |
| throw new UnsupportedOperationException(); |
| } |
| if (constantPoolInfoGotten) { |
| if (constantPoolBytesRef == null) { |
| return null; |
| } |
| byte[] cpbytes = constantPoolBytesRef.get(); |
| if (cpbytes != null) { |
| return cpbytes; |
| } |
| } |
| |
| try { |
| jdwpCPool = JDWP.ReferenceType.ConstantPool.process(vm, this); |
| } catch (JDWPException exc) { |
| if (exc.errorCode() == JDWP.Error.ABSENT_INFORMATION) { |
| constanPoolCount = 0; |
| constantPoolBytesRef = null; |
| constantPoolInfoGotten = true; |
| return null; |
| } else { |
| throw exc.toJDIException(); |
| } |
| } |
| byte[] cpbytes; |
| constanPoolCount = jdwpCPool.count; |
| cpbytes = jdwpCPool.bytes; |
| constantPoolBytesRef = new SoftReference<byte[]>(cpbytes); |
| constantPoolInfoGotten = true; |
| return cpbytes; |
| } |
| |
| public int constantPoolCount() { |
| try { |
| getConstantPoolInfo(); |
| } catch (RuntimeException exc) { |
| throw exc; |
| } |
| return constanPoolCount; |
| } |
| |
| public byte[] constantPool() { |
| byte[] cpbytes; |
| try { |
| cpbytes = getConstantPoolInfo(); |
| } catch (RuntimeException exc) { |
| throw exc; |
| } |
| if (cpbytes != null) { |
| /* |
| * Arrays are always modifiable, so it is a little unsafe |
| * to return the cached bytecodes directly; instead, we |
| * make a clone at the cost of using more memory. |
| */ |
| return cpbytes.clone(); |
| } else { |
| return null; |
| } |
| } |
| |
| // Does not need synchronization, since worst-case |
| // static info is fetched twice |
| void getModifiers() { |
| if (modifiers != -1) { |
| return; |
| } |
| try { |
| modifiers = JDWP.ReferenceType.Modifiers. |
| process(vm, this).modBits; |
| } catch (JDWPException exc) { |
| throw exc.toJDIException(); |
| } |
| } |
| |
| void decodeStatus(int status) { |
| this.status = status; |
| if ((status & JDWP.ClassStatus.PREPARED) != 0) { |
| isPrepared = true; |
| } |
| } |
| |
| void updateStatus() { |
| try { |
| decodeStatus(JDWP.ReferenceType.Status.process(vm, this).status); |
| } catch (JDWPException exc) { |
| throw exc.toJDIException(); |
| } |
| } |
| |
| void markPrepared() { |
| isPrepared = true; |
| } |
| |
| long ref() { |
| return ref; |
| } |
| |
| int indexOf(Method method) { |
| // Make sure they're all here - the obsolete method |
| // won't be found and so will have index -1 |
| return methods().indexOf(method); |
| } |
| |
| int indexOf(Field field) { |
| // Make sure they're all here |
| return fields().indexOf(field); |
| } |
| |
| /* |
| * Return true if an instance of this type |
| * can be assigned to a variable of the given type |
| */ |
| abstract boolean isAssignableTo(ReferenceType type); |
| |
| boolean isAssignableFrom(ReferenceType type) { |
| return ((ReferenceTypeImpl)type).isAssignableTo(this); |
| } |
| |
| boolean isAssignableFrom(ObjectReference object) { |
| return object == null || |
| isAssignableFrom(object.referenceType()); |
| } |
| |
| void setStatus(int status) { |
| decodeStatus(status); |
| } |
| |
| void setSignature(String signature) { |
| this.signature = signature; |
| } |
| |
| void setGenericSignature(String signature) { |
| if (signature != null && signature.length() == 0) { |
| this.genericSignature = null; |
| } else{ |
| this.genericSignature = signature; |
| } |
| this.genericSignatureGotten = true; |
| } |
| |
| private static boolean isPrimitiveArray(String signature) { |
| int i = signature.lastIndexOf('['); |
| /* |
| * TO DO: Centralize JNI signature knowledge. |
| * |
| * Ref: |
| * jdk1.4/doc/guide/jpda/jdi/com/sun/jdi/doc-files/signature.html |
| */ |
| boolean isPA; |
| if (i < 0) { |
| isPA = false; |
| } else { |
| char c = signature.charAt(i + 1); |
| isPA = (c != 'L'); |
| } |
| return isPA; |
| } |
| |
| Type findType(String signature) throws ClassNotLoadedException { |
| Type type; |
| if (signature.length() == 1) { |
| /* OTI FIX: Must be a primitive type or the void type */ |
| char sig = signature.charAt(0); |
| if (sig == 'V') { |
| type = vm.theVoidType(); |
| } else { |
| type = vm.primitiveTypeMirror((byte)sig); |
| } |
| } else { |
| // Must be a reference type. |
| ClassLoaderReferenceImpl loader = |
| (ClassLoaderReferenceImpl)classLoader(); |
| if ((loader == null) || |
| (isPrimitiveArray(signature)) //Work around 4450091 |
| ) { |
| // Caller wants type of boot class field |
| type = vm.findBootType(signature); |
| } else { |
| // Caller wants type of non-boot class field |
| type = loader.findType(signature); |
| } |
| } |
| return type; |
| } |
| |
| String loaderString() { |
| if (classLoader() != null) { |
| return "loaded by " + classLoader().toString(); |
| } else { |
| return "no class loader"; |
| } |
| } |
| |
| } |