| package org.eclipse.jdi.internal.request; |
| |
| /* |
| * (c) Copyright IBM Corp. 2000, 2001. |
| * All Rights Reserved. |
| */ |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.DataInputStream; |
| import java.io.DataOutputStream; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Map; |
| |
| import org.eclipse.jdi.internal.FieldImpl; |
| import org.eclipse.jdi.internal.LocationImpl; |
| import org.eclipse.jdi.internal.MirrorImpl; |
| import org.eclipse.jdi.internal.ObjectReferenceImpl; |
| import org.eclipse.jdi.internal.ReferenceTypeImpl; |
| import org.eclipse.jdi.internal.ThreadReferenceImpl; |
| import org.eclipse.jdi.internal.VirtualMachineImpl; |
| import org.eclipse.jdi.internal.event.EventImpl; |
| import org.eclipse.jdi.internal.jdwp.JdwpCommandPacket; |
| import org.eclipse.jdi.internal.jdwp.JdwpReplyPacket; |
| |
| import com.sun.jdi.InternalException; |
| import com.sun.jdi.ObjectCollectedException; |
| import com.sun.jdi.ObjectReference; |
| import com.sun.jdi.ReferenceType; |
| import com.sun.jdi.ThreadReference; |
| import com.sun.jdi.VMMismatchException; |
| import com.sun.jdi.request.EventRequest; |
| import com.sun.jdi.request.InvalidRequestStateException; |
| import com.sun.jdi.request.StepRequest; |
| |
| |
| /** |
| * this class implements the corresponding interfaces |
| * declared by the JDI specification. See the com.sun.jdi package |
| * for more information. |
| * |
| */ |
| public abstract class EventRequestImpl extends MirrorImpl implements EventRequest { |
| /** Jdwp constants for StepRequests. */ |
| public static final byte STEP_SIZE_MIN_JDWP = 0; |
| public static final byte STEP_SIZE_LINE_JDWP = 1; |
| public static final byte STEP_DEPTH_INTO_JDWP = 0; |
| public static final byte STEP_DEPTH_OVER_JDWP = 1; |
| public static final byte STEP_DEPTH_OUT_JDWP = 2; |
| public static final byte STEP_DEPTH_REENTER_JDWP_HCR = 3; // OTI specific for Hot Code Replacement. |
| |
| /** Jdwp constants for SuspendPolicy. */ |
| public static final byte SUSPENDPOL_NONE_JDWP = 0; |
| public static final byte SUSPENDPOL_EVENT_THREAD_JDWP = 1; |
| public static final byte SUSPENDPOL_ALL_JDWP = 2; |
| |
| /** Constants for ModifierKind. */ |
| public static final byte MODIF_KIND_COUNT = 1; |
| public static final byte MODIF_KIND_CONDITIONAL = 2; |
| public static final byte MODIF_KIND_THREADONLY = 3; |
| public static final byte MODIF_KIND_CLASSONLY = 4; |
| public static final byte MODIF_KIND_CLASSMATCH = 5; |
| public static final byte MODIF_KIND_CLASSEXCLUDE = 6; |
| public static final byte MODIF_KIND_LOCATIONONLY = 7; |
| public static final byte MODIF_KIND_EXCEPTIONONLY = 8; |
| public static final byte MODIF_KIND_FIELDONLY = 9; |
| public static final byte MODIF_KIND_STEP = 10; |
| public static final byte MODIF_KIND_INSTANCE = 11; |
| |
| /** Mapping of command codes to strings. */ |
| private static HashMap fStepSizeMap = null; |
| private static HashMap fStepDepthMap = null; |
| private static HashMap fSuspendPolicyMap = null; |
| private static HashMap fModifierKindMap = null; |
| |
| /** Flag that indicates the request was generated from inside of this JDI implementation. */ |
| private boolean fGeneratedInside = false; |
| |
| /** User property map. */ |
| private HashMap fPropertyMap; |
| |
| /** RequestId of EventRequest, assigned by the reply data of the JDWP Event Reuqest Set command, null if request had not yet been enabled. */ |
| protected RequestID fRequestID = null; |
| /** Determines the threads to suspend when the requested event occurs in the target VM. */ |
| private byte fSuspendPolicy = SUSPEND_ALL; // Default is as specified by JDI spec. |
| |
| /** |
| * Modifiers. |
| */ |
| /** Count filters. */ |
| protected ArrayList fCountFilters; |
| |
| /** Thread filters. */ |
| protected ArrayList fThreadFilters = null; |
| |
| /** Class filters. */ |
| protected ArrayList fClassFilters = null; |
| |
| /** Class filters. */ |
| protected ArrayList fClassFilterRefs = null; |
| |
| /** Class Exclusion filters. */ |
| protected ArrayList fClassExclusionFilters = null; |
| |
| /** Location filters. */ |
| protected ArrayList fLocationFilters = null; |
| |
| /** Exception filters. */ |
| protected ArrayList fExceptionFilters = null; |
| |
| /** Field filters. */ |
| protected ArrayList fFieldFilters = null; |
| |
| /** Thread step filters. */ |
| protected ArrayList fThreadStepFilters = null; |
| |
| /** Instance filters. */ |
| protected ArrayList fInstanceFilters = null; |
| |
| /** |
| * Creates new EventRequest. |
| */ |
| protected EventRequestImpl(String description, VirtualMachineImpl vmImpl) { |
| super(description, vmImpl); |
| } |
| |
| /** |
| * @return Returns string representation. |
| */ |
| public String toString() { |
| return super.toString() + (fRequestID == null ? RequestMessages.getString("EventRequestImpl._(not_enabled)_1") : RequestMessages.getString("EventRequestImpl.___2") + fRequestID); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| |
| /** |
| * @return Returns the value of the property with the specified key. |
| */ |
| public Object getProperty(Object key) { |
| if (fPropertyMap == null) |
| return null; |
| else |
| return fPropertyMap.get(key); |
| } |
| |
| /** |
| * Add an arbitrary key/value "property" to this request. |
| */ |
| public void putProperty(Object key, Object value) { |
| if (fPropertyMap == null) |
| fPropertyMap = new HashMap(); |
| |
| if (value == null) |
| fPropertyMap.remove(key); |
| else |
| fPropertyMap.put(key, value); |
| } |
| |
| /** |
| * Sets the generated inside flag. Used for requests that are not generated by JDI requests from outside. |
| */ |
| public void setGeneratedInside() { |
| fGeneratedInside = true; |
| } |
| |
| /** |
| * @return Returns whether the event request was generated from inside of this JDI implementation. |
| */ |
| public final boolean isGeneratedInside() { |
| return fGeneratedInside; |
| } |
| |
| /** |
| * Disables event request. |
| */ |
| public void disable() { |
| if (!isEnabled()) |
| return; |
| |
| initJdwpRequest(); |
| try { |
| ByteArrayOutputStream outBytes = new ByteArrayOutputStream(); |
| DataOutputStream outData = new DataOutputStream(outBytes); |
| writeByte(eventKind(), "event kind", EventImpl.eventKindMap(), outData); //$NON-NLS-1$ |
| fRequestID.write(this, outData); |
| |
| JdwpReplyPacket replyPacket = requestVM(JdwpCommandPacket.ER_CLEAR, outBytes); |
| switch (replyPacket.errorCode()) { |
| case JdwpReplyPacket.NOT_FOUND: |
| throw new InvalidRequestStateException(); |
| } |
| defaultReplyErrorHandler(replyPacket.errorCode()); |
| fRequestID = null; |
| } catch (IOException e) { |
| defaultIOExceptionHandler(e); |
| } finally { |
| handledJdwpRequest(); |
| } |
| } |
| |
| /** |
| * Enables event request. |
| */ |
| public void enable() { |
| if (isEnabled()) |
| return; |
| |
| initJdwpRequest(); |
| try { |
| ByteArrayOutputStream outBytes = new ByteArrayOutputStream(); |
| DataOutputStream outData = new DataOutputStream(outBytes); |
| writeByte(eventKind(), "event kind", EventImpl.eventKindMap(), outData); //$NON-NLS-1$ |
| writeByte(suspendPolicyJDWP(), "suspend policy", EventRequestImpl.suspendPolicyMap(), outData); //$NON-NLS-1$ |
| writeInt(modifierCount(), "modifiers", outData); //$NON-NLS-1$ |
| writeModifiers(outData); |
| |
| JdwpReplyPacket replyPacket = requestVM(JdwpCommandPacket.ER_SET, outBytes); |
| defaultReplyErrorHandler(replyPacket.errorCode()); |
| DataInputStream replyData = replyPacket.dataInStream(); |
| fRequestID = RequestID.read(this, replyData); |
| virtualMachineImpl().eventRequestManagerImpl().addRequestIDMapping(this); |
| } catch (IOException e) { |
| defaultIOExceptionHandler(e); |
| } finally { |
| handledJdwpRequest(); |
| } |
| } |
| |
| /** |
| * Clear all breakpoints (used by EventRequestManager). |
| */ |
| public static void clearAllBreakpoints(MirrorImpl mirror) { |
| mirror.initJdwpRequest(); |
| try { |
| JdwpReplyPacket replyPacket = mirror.requestVM(JdwpCommandPacket.ER_CLEAR_ALL_BREAKPOINTS); |
| mirror.defaultReplyErrorHandler(replyPacket.errorCode()); |
| } finally { |
| mirror.handledJdwpRequest(); |
| } |
| } |
| |
| /** |
| * @return Returns whether event request is enabled. |
| */ |
| public final boolean isEnabled() { |
| return fRequestID != null; |
| } |
| |
| /** |
| * Disables or enables event request. |
| */ |
| public void setEnabled(boolean enable) { |
| if (enable) |
| enable(); |
| else |
| disable(); |
| } |
| |
| /** |
| * @exception InvalidRequestStateException is thrown if this request is enabled. |
| */ |
| public void checkDisabled() throws InvalidRequestStateException { |
| if (isEnabled()) |
| throw new InvalidRequestStateException(); |
| } |
| |
| /** |
| * Sets suspend policy. |
| */ |
| public void setSuspendPolicy(int suspendPolicy) { |
| fSuspendPolicy = (byte)suspendPolicy; |
| if (isEnabled()) { |
| disable(); |
| enable(); |
| } |
| } |
| |
| /** |
| * @return Returns suspend policy. |
| */ |
| public int suspendPolicy() { |
| return fSuspendPolicy; |
| } |
| |
| /** |
| * @return Returns requestID, or null if request ID is not (yet) assigned. |
| */ |
| public final RequestID requestID() { |
| return fRequestID; |
| } |
| |
| /** |
| * Sets countfilter. |
| */ |
| public void addCountFilter(int count) throws InvalidRequestStateException { |
| checkDisabled(); |
| if (fCountFilters == null) |
| fCountFilters = new ArrayList(); |
| |
| fCountFilters.add(new Integer(count)); |
| } |
| |
| /** |
| * Restricts reported events to those in the given thread. |
| */ |
| public void addThreadFilter(ThreadReference threadFilter) throws ObjectCollectedException, VMMismatchException, InvalidRequestStateException { |
| checkVM(threadFilter); |
| checkDisabled(); |
| if (threadFilter.isCollected()) |
| throw new ObjectCollectedException(); |
| if (fThreadFilters == null) |
| fThreadFilters = new ArrayList(); |
| |
| fThreadFilters.add(threadFilter); |
| } |
| |
| /** |
| * Restricts the events generated by this request to the preparation of reference types whose name matches this restricted regular expression. |
| */ |
| public void addClassFilter(ReferenceType filter) throws VMMismatchException, InvalidRequestStateException { |
| checkVM(filter); |
| checkDisabled(); |
| if (fClassFilterRefs == null) |
| fClassFilterRefs = new ArrayList(); |
| |
| fClassFilterRefs.add(filter); |
| } |
| |
| /** |
| * Restricts the events generated by this request to be the preparation of the given reference type and any subtypes. |
| */ |
| public void addClassFilter(String filter) throws InvalidRequestStateException { |
| checkDisabled(); |
| if (fClassFilters == null) |
| fClassFilters = new ArrayList(); |
| |
| fClassFilters.add(filter); |
| } |
| |
| /** |
| * Restricts the events generated by this request to the preparation of reference types whose name does not match this restricted regular expression. |
| */ |
| public void addClassExclusionFilter(String filter) throws InvalidRequestStateException { |
| checkDisabled(); |
| if (fClassExclusionFilters == null) |
| fClassExclusionFilters = new ArrayList(); |
| |
| fClassExclusionFilters.add(filter); |
| } |
| |
| /** |
| * Restricts the events generated by this request to those that occur at the given location. |
| */ |
| public void addLocationFilter(LocationImpl location) throws VMMismatchException { |
| // Used in createBreakpointRequest. |
| checkVM(location); |
| if (fLocationFilters == null) |
| fLocationFilters = new ArrayList(); |
| |
| fLocationFilters.add(location); |
| } |
| |
| /** |
| * Restricts reported exceptions by their class and whether they are caught or uncaught. |
| */ |
| public void addExceptionFilter(ReferenceTypeImpl refType, boolean notifyCaught, boolean notifyUncaught) throws VMMismatchException { |
| // refType Null means report exceptions of all types. |
| if (refType != null) |
| checkVM(refType); |
| |
| if (fExceptionFilters == null) |
| fExceptionFilters = new ArrayList(); |
| |
| ExceptionFilter filter = new ExceptionFilter(); |
| filter.fException = refType; |
| filter.fNotifyCaught = notifyCaught; |
| filter.fNotifyUncaught = notifyUncaught; |
| fExceptionFilters.add(filter); |
| } |
| |
| /** |
| * Restricts reported events to those that occur for a given field. |
| */ |
| public void addFieldFilter(FieldImpl field) throws VMMismatchException { |
| // Used in createXWatchpointRequest methods. |
| checkVM(field); |
| if (fFieldFilters == null) |
| fFieldFilters = new ArrayList(); |
| |
| fFieldFilters.add(field); |
| } |
| |
| /** |
| * Restricts reported step events to those which satisfy depth and size constraints. |
| */ |
| public void addStepFilter(ThreadReferenceImpl thread, int size, int depth) throws VMMismatchException, ObjectCollectedException { |
| // Used in createStepRequest. |
| checkVM(thread); |
| if (thread.isCollected()) |
| throw new ObjectCollectedException(); |
| |
| if (fThreadStepFilters == null) |
| fThreadStepFilters = new ArrayList(); |
| |
| ThreadStepFilter filter = new ThreadStepFilter(); |
| filter.fThread = thread; |
| filter.fThreadStepSize = size; |
| filter.fThreadStepDepth = depth; |
| fThreadStepFilters.add(filter); |
| } |
| |
| public void addInstanceFilter(ObjectReference instance) { |
| checkVM(instance); |
| if (fInstanceFilters == null) { |
| fInstanceFilters = new ArrayList(); |
| } |
| fInstanceFilters.add(instance); |
| } |
| |
| /** |
| * From here on JDWP functionality of EventRequest is implemented. |
| */ |
| |
| /** |
| * @return Returns JDWP constant for suspend policy. |
| */ |
| public byte suspendPolicyJDWP() { |
| switch (fSuspendPolicy) { |
| case SUSPEND_NONE: |
| return SUSPENDPOL_NONE_JDWP; |
| case SUSPEND_EVENT_THREAD: |
| return SUSPENDPOL_EVENT_THREAD_JDWP; |
| case SUSPEND_ALL: |
| return SUSPENDPOL_ALL_JDWP; |
| default: |
| throw new InternalException(RequestMessages.getString("EventRequestImpl.Invalid_suspend_policy_encountered___3") + fSuspendPolicy); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * @return Returns JDWP constant for step size. |
| */ |
| public int threadStepSizeJDWP(int threadStepSize) { |
| switch (threadStepSize) { |
| case StepRequest.STEP_MIN: |
| return STEP_SIZE_MIN_JDWP; |
| case StepRequest.STEP_LINE: |
| return STEP_SIZE_LINE_JDWP; |
| default: |
| throw new InternalException(RequestMessages.getString("EventRequestImpl.Invalid_step_size_encountered___4") + threadStepSize); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * @return Returns JDWP constant for step depth. |
| */ |
| public int threadStepDepthJDWP(int threadStepDepth) { |
| switch (threadStepDepth) { |
| case StepRequest.STEP_INTO: |
| return STEP_DEPTH_INTO_JDWP; |
| case StepRequest.STEP_OVER: |
| return STEP_DEPTH_OVER_JDWP; |
| case StepRequest.STEP_OUT: |
| return STEP_DEPTH_OUT_JDWP; |
| default: |
| throw new InternalException(RequestMessages.getString("EventRequestImpl.Invalid_step_depth_encountered___5") + threadStepDepth); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * @return Returns JDWP EventKind. |
| */ |
| protected abstract byte eventKind(); |
| |
| /** |
| * @return Returns true if modifier count is set. |
| */ |
| private boolean modifierCountIsSet() { |
| return (fCountFilters != null); |
| } |
| |
| /** |
| * @return Returns number of modifiers. |
| */ |
| protected int modifierCount() { |
| int count = 0; |
| |
| if (fCountFilters != null) |
| count += fCountFilters.size(); |
| if (fThreadFilters != null) |
| count += fThreadFilters.size(); |
| if (fClassFilterRefs != null) |
| count += fClassFilterRefs.size(); |
| if (fClassFilters != null) |
| count += fClassFilters.size(); |
| if (fClassExclusionFilters != null) |
| count += fClassExclusionFilters.size(); |
| if (fLocationFilters != null) |
| count += fLocationFilters.size(); |
| if (fExceptionFilters != null) |
| count += fExceptionFilters.size(); |
| if (fFieldFilters != null) |
| count += fFieldFilters.size(); |
| if (fThreadStepFilters != null) |
| count += fThreadStepFilters.size(); |
| if (fInstanceFilters != null) |
| count += fInstanceFilters.size(); |
| |
| return count; |
| } |
| |
| /** |
| * Writes JDWP bytestream representation of modifiers. |
| */ |
| protected void writeModifiers(DataOutputStream outData) throws IOException { |
| // Note: for some reason the order of these modifiers matters when communicating with SUN's VM. |
| // It seems to expect them 'the wrong way around'. |
| if (fThreadStepFilters != null) { |
| for (int i = 0; i < fThreadStepFilters.size(); i++) { |
| ThreadStepFilter filter = (ThreadStepFilter)fThreadStepFilters.get(i); |
| writeByte(MODIF_KIND_STEP, "modifier", modifierKindMap(), outData); //$NON-NLS-1$ |
| filter.fThread.write(this, outData); |
| writeInt(threadStepSizeJDWP(filter.fThreadStepSize), "step size", outData); //$NON-NLS-1$ |
| writeInt(threadStepDepthJDWP(filter.fThreadStepDepth), "step depth", outData); //$NON-NLS-1$ |
| } |
| } |
| if (fFieldFilters != null) { |
| for (int i = 0; i < fFieldFilters.size(); i++) { |
| writeByte(MODIF_KIND_FIELDONLY, "modifier", modifierKindMap(), outData); //$NON-NLS-1$ |
| ((FieldImpl)fFieldFilters.get(i)).writeWithReferenceType(this, outData); |
| } |
| } |
| if (fExceptionFilters != null) { |
| for (int i = 0; i < fExceptionFilters.size(); i++) { |
| ExceptionFilter filter = (ExceptionFilter)fExceptionFilters.get(i); |
| writeByte(MODIF_KIND_EXCEPTIONONLY, "modifier", modifierKindMap(), outData); //$NON-NLS-1$ |
| if (filter.fException != null) |
| filter.fException.write(this, outData); |
| else |
| ReferenceTypeImpl.writeNull(this, outData); |
| |
| writeBoolean(filter.fNotifyCaught, "notify caught", outData); //$NON-NLS-1$ |
| writeBoolean(filter.fNotifyUncaught, "notify uncaught", outData); //$NON-NLS-1$ |
| } |
| } |
| if (fLocationFilters != null) { |
| for (int i = 0; i < fLocationFilters.size(); i++) { |
| writeByte(MODIF_KIND_LOCATIONONLY, "modifier", modifierKindMap(), outData); //$NON-NLS-1$ |
| ((LocationImpl)fLocationFilters.get(i)).write(this, outData); |
| } |
| } |
| if (fClassExclusionFilters != null) { |
| for (int i = 0; i < fClassExclusionFilters.size(); i++) { |
| writeByte(MODIF_KIND_CLASSEXCLUDE, "modifier", modifierKindMap(), outData); //$NON-NLS-1$ |
| writeString((String)fClassExclusionFilters.get(i), "class excl. filter", outData); //$NON-NLS-1$ |
| } |
| } |
| if (fClassFilters != null) { |
| for (int i = 0; i < fClassFilters.size(); i++) { |
| writeByte(MODIF_KIND_CLASSMATCH, "modifier", modifierKindMap(), outData); //$NON-NLS-1$ |
| writeString((String)fClassFilters.get(i), "class filter", outData); //$NON-NLS-1$ |
| } |
| } |
| if (fClassFilterRefs != null) { |
| for (int i = 0; i < fClassFilterRefs.size(); i++) { |
| writeByte(MODIF_KIND_CLASSONLY, "modifier", modifierKindMap(), outData); //$NON-NLS-1$ |
| ((ReferenceTypeImpl)fClassFilterRefs.get(i)).write(this, outData); |
| } |
| } |
| if (fThreadFilters != null) { |
| for (int i = 0; i < fThreadFilters.size(); i++) { |
| writeByte(MODIF_KIND_THREADONLY, "modifier", modifierKindMap(), outData); //$NON-NLS-1$ |
| ((ThreadReferenceImpl)fThreadFilters.get(i)).write(this, outData); |
| } |
| } |
| if (fCountFilters != null) { |
| for (int i = 0; i < fCountFilters.size(); i++) { |
| writeByte(MODIF_KIND_COUNT, "modifier", modifierKindMap(), outData); //$NON-NLS-1$ |
| writeInt(((Integer)fCountFilters.get(i)).intValue(), "count filter", outData); //$NON-NLS-1$ |
| } |
| } |
| if (fInstanceFilters != null) { |
| for (int i = 0; i < fInstanceFilters.size(); i++) { |
| writeByte(MODIF_KIND_INSTANCE, "modifier", modifierKindMap(), outData); //$NON-NLS-1$ |
| ((ObjectReferenceImpl)fInstanceFilters.get(i)).write(this, outData); |
| } |
| } |
| } |
| |
| /** |
| * Retrieves constant mappings. |
| */ |
| public static void getConstantMaps() { |
| if (fStepSizeMap != null) |
| return; |
| |
| java.lang.reflect.Field[] fields = EventRequestImpl.class.getDeclaredFields(); |
| fStepSizeMap = new HashMap(); |
| fStepDepthMap = new HashMap(); |
| fSuspendPolicyMap = new HashMap(); |
| fModifierKindMap = new HashMap(); |
| for (int i = 0; i < fields.length; i++) { |
| java.lang.reflect.Field field = fields[i]; |
| if ((field.getModifiers() & java.lang.reflect.Modifier.PUBLIC) == 0 || (field.getModifiers() & java.lang.reflect.Modifier.STATIC) == 0 || (field.getModifiers() & java.lang.reflect.Modifier.FINAL) == 0) |
| continue; |
| |
| try { |
| String name = field.getName(); |
| Integer intValue = new Integer(field.getInt(null)); |
| if (name.startsWith("STEP_SIZE_")) { //$NON-NLS-1$ |
| name = name.substring(10); |
| fStepSizeMap.put(intValue, name); |
| } else if (name.startsWith("STEP_DEPTH_")) { //$NON-NLS-1$ |
| name = name.substring(11); |
| fStepDepthMap.put(intValue, name); |
| } else if (name.startsWith("SUSPENDPOL_")) { //$NON-NLS-1$ |
| name = name.substring(11); |
| fSuspendPolicyMap.put(intValue, name); |
| } else if (name.startsWith("MODIF_KIND_")) { //$NON-NLS-1$ |
| name = name.substring(11); |
| fModifierKindMap.put(intValue, name); |
| } |
| } catch (IllegalAccessException e) { |
| // Will not occur for own class. |
| } catch (IllegalArgumentException e) { |
| // Should not occur. |
| // We should take care that all public static final constants |
| // in this class are numbers that are convertible to int. |
| } |
| } |
| } |
| |
| /** |
| * @return Returns a map with string representations of tags. |
| */ |
| public static Map stepSizeMap() { |
| getConstantMaps(); |
| return fStepSizeMap; |
| } |
| |
| /** |
| * @return Returns a map with string representations of tags. |
| */ |
| public static Map stepDepthMap() { |
| getConstantMaps(); |
| return fStepDepthMap; |
| } |
| |
| /** |
| * @return Returns a map with string representations of type tags. |
| */ |
| public static Map suspendPolicyMap() { |
| getConstantMaps(); |
| return fSuspendPolicyMap; |
| } |
| |
| /** |
| * @return Returns a map with string representations of type tags. |
| */ |
| public static Map modifierKindMap() { |
| getConstantMaps(); |
| return fModifierKindMap; |
| } |
| |
| class ExceptionFilter { |
| /** If non-null, specifies that exceptions which are instances of fExceptionFilterRef will be reported. */ |
| ReferenceTypeImpl fException = null; |
| /** If true, caught exceptions will be reported. */ |
| boolean fNotifyCaught = false; |
| /** If true, uncaught exceptions will be reported. */ |
| boolean fNotifyUncaught = false; |
| } |
| |
| class ThreadStepFilter { |
| /** ThreadReference of thread in which to step. */ |
| protected ThreadReferenceImpl fThread = null; |
| /** Size of each step. */ |
| protected int fThreadStepSize; |
| /** Relative call stack limit. */ |
| protected int fThreadStepDepth; |
| } |
| } |