Back to index...

	/*
	* 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();
	}
	}

Back to index...