| /* |
| * Copyright (c) 1998, 2013, 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 com.sun.jdi.event.*; |
| import com.sun.jdi.request.*; |
| |
| import java.util.*; |
| enum EventDestination {UNKNOWN_EVENT, INTERNAL_EVENT, CLIENT_EVENT}; |
| |
| /* |
| * An EventSet is normally created by the transport reader thread when |
| * it reads a JDWP Composite command. The constructor doesn't unpack |
| * the events contained in the Composite command and create EventImpls |
| * for them because that process might involve calling back into the back-end |
| * which should not be done by the transport reader thread. Instead, |
| * the raw bytes of the packet are read and stored in the EventSet. |
| * The EventSet is then added to each EventQueue. When an EventSet is |
| * removed from an EventQueue, the EventSetImpl.build() method is called. |
| * This method reads the packet bytes and creates the actual EventImpl objects. |
| * build() also filters out events for our internal handler and puts them in |
| * their own EventSet. This means that the EventImpls that are in the EventSet |
| * that is on the queues are all for client requests. |
| */ |
| public class EventSetImpl extends ArrayList<Event> implements EventSet { |
| private static final long serialVersionUID = -4857338819787924570L; |
| private VirtualMachineImpl vm; // we implement Mirror |
| private Packet pkt; |
| private byte suspendPolicy; |
| private EventSetImpl internalEventSet; |
| |
| public String toString() { |
| String string = "event set, policy:" + suspendPolicy + |
| ", count:" + this.size() + " = {"; |
| boolean first = true; |
| for (Event event : this) { |
| if (!first) { |
| string += ", "; |
| } |
| string += event.toString(); |
| first = false; |
| } |
| string += "}"; |
| return string; |
| } |
| |
| abstract class EventImpl extends MirrorImpl implements Event { |
| |
| private final byte eventCmd; |
| private final int requestID; |
| // This is set only for client requests, not internal requests. |
| private final EventRequest request; |
| |
| /** |
| * Constructor for events. |
| */ |
| protected EventImpl(JDWP.Event.Composite.Events.EventsCommon evt, |
| int requestID) { |
| super(EventSetImpl.this.vm); |
| this.eventCmd = evt.eventKind(); |
| this.requestID = requestID; |
| EventRequestManagerImpl ermi = EventSetImpl.this. |
| vm.eventRequestManagerImpl(); |
| this.request = ermi.request(eventCmd, requestID); |
| } |
| |
| /* |
| * Override superclass back to default equality |
| */ |
| public boolean equals(Object obj) { |
| return this == obj; |
| } |
| |
| public int hashCode() { |
| return System.identityHashCode(this); |
| } |
| |
| /** |
| * Constructor for VM disconnected events. |
| */ |
| protected EventImpl(byte eventCmd) { |
| super(EventSetImpl.this.vm); |
| this.eventCmd = eventCmd; |
| this.requestID = 0; |
| this.request = null; |
| } |
| |
| public EventRequest request() { |
| return request; |
| } |
| |
| int requestID() { |
| return requestID; |
| } |
| |
| EventDestination destination() { |
| /* |
| * We need to decide if this event is for |
| * 1. an internal request |
| * 2. a client request that is no longer available, ie |
| * it has been deleted, or disabled and re-enabled |
| * which gives it a new ID. |
| * 3. a current client request that is disabled |
| * 4. a current enabled client request. |
| * |
| * We will filter this set into a set |
| * that contains only 1s for our internal queue |
| * and a set that contains only 4s for our client queue. |
| * If we get an EventSet that contains only 2 and 3 |
| * then we have to resume it if it is not SUSPEND_NONE |
| * because no one else will. |
| */ |
| if (requestID == 0) { |
| /* An unsolicited event. These have traditionally |
| * been treated as client events. |
| */ |
| return EventDestination.CLIENT_EVENT; |
| } |
| |
| // Is this an event for a current client request? |
| if (request == null) { |
| // Nope. Is it an event for an internal request? |
| EventRequestManagerImpl ermi = this.vm.getInternalEventRequestManager(); |
| if (ermi.request(eventCmd, requestID) != null) { |
| // Yep |
| return EventDestination.INTERNAL_EVENT; |
| } |
| return EventDestination.UNKNOWN_EVENT; |
| } |
| |
| // We found a client request |
| if (request.isEnabled()) { |
| return EventDestination.CLIENT_EVENT; |
| } |
| return EventDestination.UNKNOWN_EVENT; |
| } |
| |
| abstract String eventName(); |
| |
| public String toString() { |
| return eventName(); |
| } |
| |
| } |
| |
| abstract class ThreadedEventImpl extends EventImpl { |
| private ThreadReference thread; |
| |
| ThreadedEventImpl(JDWP.Event.Composite.Events.EventsCommon evt, |
| int requestID, ThreadReference thread) { |
| super(evt, requestID); |
| this.thread = thread; |
| } |
| |
| public ThreadReference thread() { |
| return thread; |
| } |
| |
| public String toString() { |
| return eventName() + " in thread " + thread.name(); |
| } |
| } |
| |
| abstract class LocatableEventImpl extends ThreadedEventImpl |
| implements Locatable { |
| private Location location; |
| |
| LocatableEventImpl(JDWP.Event.Composite.Events.EventsCommon evt, |
| int requestID, |
| ThreadReference thread, Location location) { |
| super(evt, requestID, thread); |
| this.location = location; |
| } |
| |
| public Location location() { |
| return location; |
| } |
| |
| /** |
| * For MethodEntry and MethodExit |
| */ |
| public Method method() { |
| return location.method(); |
| } |
| |
| public String toString() { |
| return eventName() + "@" + |
| ((location() == null) ? " null" : location().toString()) + |
| " in thread " + thread().name(); |
| } |
| } |
| |
| class BreakpointEventImpl extends LocatableEventImpl |
| implements BreakpointEvent { |
| BreakpointEventImpl(JDWP.Event.Composite.Events.Breakpoint evt) { |
| super(evt, evt.requestID, evt.thread, evt.location); |
| } |
| |
| String eventName() { |
| return "BreakpointEvent"; |
| } |
| } |
| |
| class StepEventImpl extends LocatableEventImpl implements StepEvent { |
| StepEventImpl(JDWP.Event.Composite.Events.SingleStep evt) { |
| super(evt, evt.requestID, evt.thread, evt.location); |
| } |
| |
| String eventName() { |
| return "StepEvent"; |
| } |
| } |
| |
| class MethodEntryEventImpl extends LocatableEventImpl |
| implements MethodEntryEvent { |
| MethodEntryEventImpl(JDWP.Event.Composite.Events.MethodEntry evt) { |
| super(evt, evt.requestID, evt.thread, evt.location); |
| } |
| |
| String eventName() { |
| return "MethodEntryEvent"; |
| } |
| } |
| |
| class MethodExitEventImpl extends LocatableEventImpl |
| implements MethodExitEvent { |
| private Value returnVal = null; |
| |
| MethodExitEventImpl(JDWP.Event.Composite.Events.MethodExit evt) { |
| super(evt, evt.requestID, evt.thread, evt.location); |
| } |
| |
| MethodExitEventImpl(JDWP.Event.Composite.Events.MethodExitWithReturnValue evt) { |
| super(evt, evt.requestID, evt.thread, evt.location); |
| returnVal = evt.value; |
| } |
| |
| String eventName() { |
| return "MethodExitEvent"; |
| } |
| |
| public Value returnValue() { |
| if (!this.vm.canGetMethodReturnValues()) { |
| throw new UnsupportedOperationException( |
| "target does not support return values in MethodExit events"); |
| } |
| return returnVal; |
| } |
| |
| } |
| |
| class MonitorContendedEnterEventImpl extends LocatableEventImpl |
| implements MonitorContendedEnterEvent { |
| private ObjectReference monitor = null; |
| |
| MonitorContendedEnterEventImpl(JDWP.Event.Composite.Events.MonitorContendedEnter evt) { |
| super(evt, evt.requestID, evt.thread, evt.location); |
| this.monitor = evt.object; |
| } |
| |
| String eventName() { |
| return "MonitorContendedEnter"; |
| } |
| |
| public ObjectReference monitor() { |
| return monitor; |
| }; |
| |
| } |
| |
| class MonitorContendedEnteredEventImpl extends LocatableEventImpl |
| implements MonitorContendedEnteredEvent { |
| private ObjectReference monitor = null; |
| |
| MonitorContendedEnteredEventImpl(JDWP.Event.Composite.Events.MonitorContendedEntered evt) { |
| super(evt, evt.requestID, evt.thread, evt.location); |
| this.monitor = evt.object; |
| } |
| |
| String eventName() { |
| return "MonitorContendedEntered"; |
| } |
| |
| public ObjectReference monitor() { |
| return monitor; |
| }; |
| |
| } |
| |
| class MonitorWaitEventImpl extends LocatableEventImpl |
| implements MonitorWaitEvent { |
| private ObjectReference monitor = null; |
| private long timeout; |
| |
| MonitorWaitEventImpl(JDWP.Event.Composite.Events.MonitorWait evt) { |
| super(evt, evt.requestID, evt.thread, evt.location); |
| this.monitor = evt.object; |
| this.timeout = evt.timeout; |
| } |
| |
| String eventName() { |
| return "MonitorWait"; |
| } |
| |
| public ObjectReference monitor() { |
| return monitor; |
| }; |
| |
| public long timeout() { |
| return timeout; |
| } |
| } |
| |
| class MonitorWaitedEventImpl extends LocatableEventImpl |
| implements MonitorWaitedEvent { |
| private ObjectReference monitor = null; |
| private boolean timed_out; |
| |
| MonitorWaitedEventImpl(JDWP.Event.Composite.Events.MonitorWaited evt) { |
| super(evt, evt.requestID, evt.thread, evt.location); |
| this.monitor = evt.object; |
| this.timed_out = evt.timed_out; |
| } |
| |
| String eventName() { |
| return "MonitorWaited"; |
| } |
| |
| public ObjectReference monitor() { |
| return monitor; |
| }; |
| |
| public boolean timedout() { |
| return timed_out; |
| } |
| } |
| |
| class ClassPrepareEventImpl extends ThreadedEventImpl |
| implements ClassPrepareEvent { |
| private ReferenceType referenceType; |
| |
| ClassPrepareEventImpl(JDWP.Event.Composite.Events.ClassPrepare evt) { |
| super(evt, evt.requestID, evt.thread); |
| referenceType = this.vm.referenceType(evt.typeID, evt.refTypeTag, |
| evt.signature); |
| ((ReferenceTypeImpl)referenceType).setStatus(evt.status); |
| } |
| |
| public ReferenceType referenceType() { |
| return referenceType; |
| } |
| |
| String eventName() { |
| return "ClassPrepareEvent"; |
| } |
| } |
| |
| class ClassUnloadEventImpl extends EventImpl implements ClassUnloadEvent { |
| private String classSignature; |
| |
| ClassUnloadEventImpl(JDWP.Event.Composite.Events.ClassUnload evt) { |
| super(evt, evt.requestID); |
| this.classSignature = evt.signature; |
| } |
| |
| public String className() { |
| return classSignature.substring(1, classSignature.length()-1) |
| .replace('/', '.'); |
| } |
| |
| public String classSignature() { |
| return classSignature; |
| } |
| |
| String eventName() { |
| return "ClassUnloadEvent"; |
| } |
| } |
| |
| class ExceptionEventImpl extends LocatableEventImpl |
| implements ExceptionEvent { |
| private ObjectReference exception; |
| private Location catchLocation; |
| |
| ExceptionEventImpl(JDWP.Event.Composite.Events.Exception evt) { |
| super(evt, evt.requestID, evt.thread, evt.location); |
| this.exception = evt.exception; |
| this.catchLocation = evt.catchLocation; |
| } |
| |
| public ObjectReference exception() { |
| return exception; |
| } |
| |
| public Location catchLocation() { |
| return catchLocation; |
| } |
| |
| String eventName() { |
| return "ExceptionEvent"; |
| } |
| } |
| |
| class ThreadDeathEventImpl extends ThreadedEventImpl |
| implements ThreadDeathEvent { |
| ThreadDeathEventImpl(JDWP.Event.Composite.Events.ThreadDeath evt) { |
| super(evt, evt.requestID, evt.thread); |
| } |
| |
| String eventName() { |
| return "ThreadDeathEvent"; |
| } |
| } |
| |
| class ThreadStartEventImpl extends ThreadedEventImpl |
| implements ThreadStartEvent { |
| ThreadStartEventImpl(JDWP.Event.Composite.Events.ThreadStart evt) { |
| super(evt, evt.requestID, evt.thread); |
| } |
| |
| String eventName() { |
| return "ThreadStartEvent"; |
| } |
| } |
| |
| class VMStartEventImpl extends ThreadedEventImpl |
| implements VMStartEvent { |
| VMStartEventImpl(JDWP.Event.Composite.Events.VMStart evt) { |
| super(evt, evt.requestID, evt.thread); |
| } |
| |
| String eventName() { |
| return "VMStartEvent"; |
| } |
| } |
| |
| class VMDeathEventImpl extends EventImpl implements VMDeathEvent { |
| |
| VMDeathEventImpl(JDWP.Event.Composite.Events.VMDeath evt) { |
| super(evt, evt.requestID); |
| } |
| |
| String eventName() { |
| return "VMDeathEvent"; |
| } |
| } |
| |
| class VMDisconnectEventImpl extends EventImpl |
| implements VMDisconnectEvent { |
| |
| VMDisconnectEventImpl() { |
| super((byte)JDWP.EventKind.VM_DISCONNECTED); |
| } |
| |
| String eventName() { |
| return "VMDisconnectEvent"; |
| } |
| } |
| |
| abstract class WatchpointEventImpl extends LocatableEventImpl |
| implements WatchpointEvent { |
| private final ReferenceTypeImpl refType; |
| private final long fieldID; |
| private final ObjectReference object; |
| private Field field = null; |
| |
| WatchpointEventImpl(JDWP.Event.Composite.Events.EventsCommon evt, |
| int requestID, |
| ThreadReference thread, Location location, |
| byte refTypeTag, long typeID, long fieldID, |
| ObjectReference object) { |
| super(evt, requestID, thread, location); |
| this.refType = this.vm.referenceType(typeID, refTypeTag); |
| this.fieldID = fieldID; |
| this.object = object; |
| } |
| |
| public Field field() { |
| if (field == null) { |
| field = refType.getFieldMirror(fieldID); |
| } |
| return field; |
| } |
| |
| public ObjectReference object() { |
| return object; |
| } |
| |
| public Value valueCurrent() { |
| if (object == null) { |
| return refType.getValue(field()); |
| } else { |
| return object.getValue(field()); |
| } |
| } |
| } |
| |
| class AccessWatchpointEventImpl extends WatchpointEventImpl |
| implements AccessWatchpointEvent { |
| |
| AccessWatchpointEventImpl(JDWP.Event.Composite.Events.FieldAccess evt) { |
| super(evt, evt.requestID, evt.thread, evt.location, |
| evt.refTypeTag, evt.typeID, evt.fieldID, evt.object); |
| } |
| |
| String eventName() { |
| return "AccessWatchpoint"; |
| } |
| } |
| |
| class ModificationWatchpointEventImpl extends WatchpointEventImpl |
| implements ModificationWatchpointEvent { |
| Value newValue; |
| |
| ModificationWatchpointEventImpl( |
| JDWP.Event.Composite.Events.FieldModification evt) { |
| super(evt, evt.requestID, evt.thread, evt.location, |
| evt.refTypeTag, evt.typeID, evt.fieldID, evt.object); |
| this.newValue = evt.valueToBe; |
| } |
| |
| public Value valueToBe() { |
| return newValue; |
| } |
| |
| String eventName() { |
| return "ModificationWatchpoint"; |
| } |
| } |
| |
| /** |
| * Events are constructed on the thread which reads all data from the |
| * transport. This means that the packet cannot be converted to real |
| * JDI objects as that may involve further communications with the |
| * back end which would deadlock. |
| * |
| * Hence the {@link #build()} method below called by EventQueue. |
| */ |
| EventSetImpl(VirtualMachine aVm, Packet pkt) { |
| super(); |
| |
| // From "MirrorImpl": |
| // Yes, its a bit of a hack. But by doing it this |
| // way, this is the only place we have to change |
| // typing to substitute a new impl. |
| vm = (VirtualMachineImpl)aVm; |
| |
| this.pkt = pkt; |
| } |
| |
| /** |
| * Constructor for special events like VM disconnected |
| */ |
| EventSetImpl(VirtualMachine aVm, byte eventCmd) { |
| this(aVm, null); |
| suspendPolicy = JDWP.SuspendPolicy.NONE; |
| switch (eventCmd) { |
| case JDWP.EventKind.VM_DISCONNECTED: |
| addEvent(new VMDisconnectEventImpl()); |
| break; |
| |
| default: |
| throw new InternalException("Bad singleton event code"); |
| } |
| } |
| |
| private void addEvent(EventImpl evt) { |
| // Note that this class has a public add method that throws |
| // an exception so that clients can't modify the EventSet |
| super.add(evt); |
| } |
| |
| /* |
| * Complete the construction of an EventSet. This is called from |
| * an event handler thread. It upacks the JDWP events inside |
| * the packet and creates EventImpls for them. The EventSet is already |
| * on EventQueues when this is called, so it has to be synch. |
| */ |
| synchronized void build() { |
| if (pkt == null) { |
| return; |
| } |
| PacketStream ps = new PacketStream(vm, pkt); |
| JDWP.Event.Composite compEvt = new JDWP.Event.Composite(vm, ps); |
| suspendPolicy = compEvt.suspendPolicy; |
| if ((vm.traceFlags & VirtualMachine.TRACE_EVENTS) != 0) { |
| switch(suspendPolicy) { |
| case JDWP.SuspendPolicy.ALL: |
| vm.printTrace("EventSet: SUSPEND_ALL"); |
| break; |
| |
| case JDWP.SuspendPolicy.EVENT_THREAD: |
| vm.printTrace("EventSet: SUSPEND_EVENT_THREAD"); |
| break; |
| |
| case JDWP.SuspendPolicy.NONE: |
| vm.printTrace("EventSet: SUSPEND_NONE"); |
| break; |
| } |
| } |
| |
| ThreadReference fix6485605 = null; |
| for (int i = 0; i < compEvt.events.length; i++) { |
| EventImpl evt = createEvent(compEvt.events[i]); |
| if ((vm.traceFlags & VirtualMachine.TRACE_EVENTS) != 0) { |
| try { |
| vm.printTrace("Event: " + evt); |
| } catch (VMDisconnectedException ee) { |
| // ignore - see bug 6502716 |
| } |
| } |
| |
| switch (evt.destination()) { |
| case UNKNOWN_EVENT: |
| // Ignore disabled, deleted, unknown events, but |
| // save the thread if there is one since we might |
| // have to resume it. Note that events for different |
| // threads can't be in the same event set. |
| if (evt instanceof ThreadedEventImpl && |
| suspendPolicy == JDWP.SuspendPolicy.EVENT_THREAD) { |
| fix6485605 = ((ThreadedEventImpl)evt).thread(); |
| } |
| continue; |
| case CLIENT_EVENT: |
| addEvent(evt); |
| break; |
| case INTERNAL_EVENT: |
| if (internalEventSet == null) { |
| internalEventSet = new EventSetImpl(this.vm, null); |
| } |
| internalEventSet.addEvent(evt); |
| break; |
| default: |
| throw new InternalException("Invalid event destination"); |
| } |
| } |
| pkt = null; // No longer needed - free it up |
| |
| // Avoid hangs described in 6296125, 6293795 |
| if (super.size() == 0) { |
| // This set has no client events. If we don't do |
| // needed resumes, no one else is going to. |
| if (suspendPolicy == JDWP.SuspendPolicy.ALL) { |
| vm.resume(); |
| } else if (suspendPolicy == JDWP.SuspendPolicy.EVENT_THREAD) { |
| // See bug 6485605. |
| if (fix6485605 != null) { |
| fix6485605.resume(); |
| } else { |
| // apparently, there is nothing to resume. |
| } |
| } |
| suspendPolicy = JDWP.SuspendPolicy.NONE; |
| |
| } |
| |
| } |
| |
| /** |
| * Filter out internal events |
| */ |
| EventSet userFilter() { |
| return this; |
| } |
| |
| /** |
| * Filter out user events. |
| */ |
| EventSet internalFilter() { |
| return this.internalEventSet; |
| } |
| |
| EventImpl createEvent(JDWP.Event.Composite.Events evt) { |
| JDWP.Event.Composite.Events.EventsCommon comm = evt.aEventsCommon; |
| switch (evt.eventKind) { |
| case JDWP.EventKind.THREAD_START: |
| return new ThreadStartEventImpl( |
| (JDWP.Event.Composite.Events.ThreadStart)comm); |
| |
| case JDWP.EventKind.THREAD_END: |
| return new ThreadDeathEventImpl( |
| (JDWP.Event.Composite.Events.ThreadDeath)comm); |
| |
| case JDWP.EventKind.EXCEPTION: |
| return new ExceptionEventImpl( |
| (JDWP.Event.Composite.Events.Exception)comm); |
| |
| case JDWP.EventKind.BREAKPOINT: |
| return new BreakpointEventImpl( |
| (JDWP.Event.Composite.Events.Breakpoint)comm); |
| |
| case JDWP.EventKind.METHOD_ENTRY: |
| return new MethodEntryEventImpl( |
| (JDWP.Event.Composite.Events.MethodEntry)comm); |
| |
| case JDWP.EventKind.METHOD_EXIT: |
| return new MethodExitEventImpl( |
| (JDWP.Event.Composite.Events.MethodExit)comm); |
| |
| case JDWP.EventKind.METHOD_EXIT_WITH_RETURN_VALUE: |
| return new MethodExitEventImpl( |
| (JDWP.Event.Composite.Events.MethodExitWithReturnValue)comm); |
| |
| case JDWP.EventKind.FIELD_ACCESS: |
| return new AccessWatchpointEventImpl( |
| (JDWP.Event.Composite.Events.FieldAccess)comm); |
| |
| case JDWP.EventKind.FIELD_MODIFICATION: |
| return new ModificationWatchpointEventImpl( |
| (JDWP.Event.Composite.Events.FieldModification)comm); |
| |
| case JDWP.EventKind.SINGLE_STEP: |
| return new StepEventImpl( |
| (JDWP.Event.Composite.Events.SingleStep)comm); |
| |
| case JDWP.EventKind.CLASS_PREPARE: |
| return new ClassPrepareEventImpl( |
| (JDWP.Event.Composite.Events.ClassPrepare)comm); |
| |
| case JDWP.EventKind.CLASS_UNLOAD: |
| return new ClassUnloadEventImpl( |
| (JDWP.Event.Composite.Events.ClassUnload)comm); |
| |
| case JDWP.EventKind.MONITOR_CONTENDED_ENTER: |
| return new MonitorContendedEnterEventImpl( |
| (JDWP.Event.Composite.Events.MonitorContendedEnter)comm); |
| |
| case JDWP.EventKind.MONITOR_CONTENDED_ENTERED: |
| return new MonitorContendedEnteredEventImpl( |
| (JDWP.Event.Composite.Events.MonitorContendedEntered)comm); |
| |
| case JDWP.EventKind.MONITOR_WAIT: |
| return new MonitorWaitEventImpl( |
| (JDWP.Event.Composite.Events.MonitorWait)comm); |
| |
| case JDWP.EventKind.MONITOR_WAITED: |
| return new MonitorWaitedEventImpl( |
| (JDWP.Event.Composite.Events.MonitorWaited)comm); |
| |
| case JDWP.EventKind.VM_START: |
| return new VMStartEventImpl( |
| (JDWP.Event.Composite.Events.VMStart)comm); |
| |
| case JDWP.EventKind.VM_DEATH: |
| return new VMDeathEventImpl( |
| (JDWP.Event.Composite.Events.VMDeath)comm); |
| |
| default: |
| // Ignore unknown event types |
| System.err.println("Ignoring event cmd " + |
| evt.eventKind + " from the VM"); |
| return null; |
| } |
| } |
| |
| public VirtualMachine virtualMachine() { |
| return vm; |
| } |
| |
| public int suspendPolicy() { |
| return EventRequestManagerImpl.JDWPtoJDISuspendPolicy(suspendPolicy); |
| } |
| |
| private ThreadReference eventThread() { |
| for (Event event : this) { |
| if (event instanceof ThreadedEventImpl) { |
| return ((ThreadedEventImpl)event).thread(); |
| } |
| } |
| return null; |
| } |
| |
| public void resume() { |
| switch (suspendPolicy()) { |
| case EventRequest.SUSPEND_ALL: |
| vm.resume(); |
| break; |
| case EventRequest.SUSPEND_EVENT_THREAD: |
| ThreadReference thread = eventThread(); |
| if (thread == null) { |
| throw new InternalException("Inconsistent suspend policy"); |
| } |
| thread.resume(); |
| break; |
| case EventRequest.SUSPEND_NONE: |
| // Do nothing |
| break; |
| default: |
| throw new InternalException("Invalid suspend policy"); |
| } |
| } |
| |
| public Iterator<Event> iterator() { |
| return new Itr(); |
| } |
| |
| public EventIterator eventIterator() { |
| return new Itr(); |
| } |
| |
| public class Itr implements EventIterator { |
| /** |
| * Index of element to be returned by subsequent call to next. |
| */ |
| int cursor = 0; |
| |
| public boolean hasNext() { |
| return cursor != size(); |
| } |
| |
| public Event next() { |
| try { |
| Event nxt = get(cursor); |
| ++cursor; |
| return nxt; |
| } catch(IndexOutOfBoundsException e) { |
| throw new NoSuchElementException(); |
| } |
| } |
| |
| public Event nextEvent() { |
| return next(); |
| } |
| |
| public void remove() { |
| throw new UnsupportedOperationException(); |
| } |
| } |
| |
| @Override |
| public Spliterator<Event> spliterator() { |
| return Spliterators.spliterator(this, Spliterator.DISTINCT); |
| } |
| |
| /* below make this unmodifiable */ |
| |
| public boolean add(Event o){ |
| throw new UnsupportedOperationException(); |
| } |
| public boolean remove(Object o) { |
| throw new UnsupportedOperationException(); |
| } |
| public boolean addAll(Collection<? extends Event> coll) { |
| throw new UnsupportedOperationException(); |
| } |
| public boolean removeAll(Collection<?> coll) { |
| throw new UnsupportedOperationException(); |
| } |
| public boolean retainAll(Collection<?> coll) { |
| throw new UnsupportedOperationException(); |
| } |
| public void clear() { |
| throw new UnsupportedOperationException(); |
| } |
| } |
