org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/breakpoints/ConditionalBreakpointHandler.java - jdt/eclipse.jdt.debug - Git at Google

 /*******************************************************************************
  * Copyright (c) 2009 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jdt.internal.debug.core.breakpoints;

 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.debug.core.DebugEvent;
 import org.eclipse.debug.core.DebugException;
 import org.eclipse.debug.core.model.IDebugTarget;
 import org.eclipse.debug.core.model.IValue;
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.dom.Message;
 import org.eclipse.jdt.debug.core.IJavaBreakpoint;
 import org.eclipse.jdt.debug.core.IJavaBreakpointListener;
 import org.eclipse.jdt.debug.core.IJavaDebugTarget;
 import org.eclipse.jdt.debug.core.IJavaLineBreakpoint;
 import org.eclipse.jdt.debug.core.IJavaPrimitiveValue;
 import org.eclipse.jdt.debug.core.IJavaStackFrame;
 import org.eclipse.jdt.debug.core.IJavaThread;
 import org.eclipse.jdt.debug.core.IJavaType;
 import org.eclipse.jdt.debug.eval.IAstEvaluationEngine;
 import org.eclipse.jdt.debug.eval.ICompiledExpression;
 import org.eclipse.jdt.debug.eval.IEvaluationListener;
 import org.eclipse.jdt.debug.eval.IEvaluationResult;
 import org.eclipse.jdt.internal.debug.core.JDIDebugPlugin;
 import org.eclipse.jdt.internal.debug.core.model.JDIDebugTarget;
 import org.eclipse.jdt.internal.debug.core.model.JDIThread;

 import com.ibm.icu.text.MessageFormat;
 import com.sun.jdi.VMDisconnectedException;

 /**
  * Breakpoint listener to handle breakpoint conditions.
  *
  * @since 3.5
  */
 public class ConditionalBreakpointHandler implements IJavaBreakpointListener {

 	/**
 	 * Whether the condition had compile or runtime errors
 	 */
 	private boolean fHasErrors = false;

 	/**
 	 * Listens for evaluation completion for condition evaluation.
 	 * If an evaluation evaluates <code>true</code> or has an error, this breakpoint
 	 * will suspend the thread in which the breakpoint was hit.
 	 * If the evaluation returns <code>false</code>, the thread is resumed.
 	 */
 	class EvaluationListener implements IEvaluationListener {

 		/**
 		 * Lock for synchronizing evaluation
 		 */
 		private Object fLock = new Object();

 		/**
 		 * The breakpoint that was hit
 		 */
 		private JavaLineBreakpoint fBreakpoint;

 		/**
 		 * Result of the vote
 		 */
 		private int fVote;

 		EvaluationListener(JavaLineBreakpoint breakpoint) {
 			fBreakpoint = breakpoint;
 		}

 		public void evaluationComplete(IEvaluationResult result) {
 			fVote = determineVote(result);
 			synchronized (fLock) {
 				fLock.notifyAll();
 			}
 		}

 		/**
 		 * Processes the result to determine whether to suspend or resume.
 		 *
 		 * @param result evaluation result
 		 * @return vote
 		 */
 		private int determineVote(IEvaluationResult result) {
 			if (result.isTerminated()) {
 				// indicates the user terminated the evaluation
 				return SUSPEND;
 			}
 			JDIThread thread= (JDIThread)result.getThread();
 			if (result.hasErrors()) {
 				DebugException exception= result.getException();
 				Throwable wrappedException= exception.getStatus().getException();
 				if (wrappedException instanceof VMDisconnectedException) {
 					// VM terminated/disconnected during evaluation
 					return DONT_SUSPEND;
 				} else {
 					fireConditionHasRuntimeErrors(fBreakpoint, exception);
 					return SUSPEND;
 				}
 			} else {
 				try {
 					IValue value= result.getValue();
 					if (fBreakpoint.isConditionSuspendOnTrue()) {
 						if (value instanceof IJavaPrimitiveValue) {
 							// Suspend when the condition evaluates true
 							IJavaPrimitiveValue javaValue= (IJavaPrimitiveValue)value;
 							if (javaValue.getJavaType().getName().equals("boolean")) { //$NON-NLS-1$
 								if (javaValue.getBooleanValue()) {
 									return SUSPEND;
 								} else {
 									return DONT_SUSPEND;
 								}
 							}
 						}
 						// result was not boolean
 						fireConditionHasRuntimeErrors(fBreakpoint, new DebugException(
 								new Status(IStatus.ERROR, JDIDebugPlugin.getUniqueIdentifier(),
 										MessageFormat.format(JDIDebugBreakpointMessages.ConditionalBreakpointHandler_1, new String[]{value.getReferenceTypeName()}))));
 						return SUSPEND;
 					} else {
 						IDebugTarget debugTarget= thread.getDebugTarget();
 						IValue lastValue= fBreakpoint.setCurrentConditionValue(debugTarget, value);
 						if (!value.equals(lastValue)) {
 							return SUSPEND;
 						} else {
 							return DONT_SUSPEND;
 						}
 					}
 				} catch (DebugException e) {
 					// Suspend when an error occurs
 					JDIDebugPlugin.log(e);
 					return SUSPEND;
 				}
 			}
 		}

 		/**
 		 * Result of the conditional expression evaluation - to resume or not resume, that
 		 * is the question.
 		 *
 		 * @return vote result
 		 */
 		int getVote() {
 			return fVote;
 		}

 		/**
 		 * Returns the lock object to synchronize this evaluation.
 		 *
 		 * @return lock object
 		 */
 		Object getLock() {
 			return fLock;
 		}
 	}

 	public void addingBreakpoint(IJavaDebugTarget target, IJavaBreakpoint breakpoint) {
 	}

 	public void breakpointHasCompilationErrors(IJavaLineBreakpoint breakpoint, Message[] errors) {
 	}

 	public void breakpointHasRuntimeException(IJavaLineBreakpoint breakpoint, DebugException exception) {
 	}

 	public int breakpointHit(IJavaThread thread, IJavaBreakpoint breakpoint) {
 		if (breakpoint instanceof IJavaLineBreakpoint) {
 			JavaLineBreakpoint lineBreakpoint = (JavaLineBreakpoint) breakpoint;
 			try {
 				final String condition= lineBreakpoint.getCondition();
 				if (condition == null) {
 					return SUSPEND;
 				}
 				EvaluationListener listener= new EvaluationListener(lineBreakpoint);
 				IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
 				IJavaProject project= lineBreakpoint.getJavaProject(frame);
 				if (project == null) {
 					fireConditionHasErrors(lineBreakpoint, new Message[]{new Message(JDIDebugBreakpointMessages.JavaLineBreakpoint_Unable_to_compile_conditional_breakpoint___missing_Java_project_context__1, -1)});
 					return SUSPEND;
 				}
 				IJavaDebugTarget target = (IJavaDebugTarget) thread.getDebugTarget();
 				IAstEvaluationEngine engine = getEvaluationEngine(target, project);
 				if (engine == null) {
 					// If no engine is available, suspend
 					return SUSPEND;
 				}
 				ICompiledExpression expression= lineBreakpoint.getExpression(thread);
 				if (expression == null) {
 					expression= engine.getCompiledExpression(condition, frame);
 					lineBreakpoint.setExpression(thread, expression);
 				}
 				if (expression.hasErrors()) {
 					fireConditionHasErrors(lineBreakpoint, getMessages(expression));
 					return SUSPEND;
 				}
 				Object lock = listener.getLock();
 				synchronized (lock) {
 					engine.evaluateExpression(expression, frame, listener, DebugEvent.EVALUATION_IMPLICIT, false);
 					// TODO: timeout?
 					try {
 						lock.wait();
 					} catch (InterruptedException e) {
 						fireConditionHasRuntimeErrors(lineBreakpoint, new DebugException(
 							new Status(IStatus.ERROR, JDIDebugPlugin.getUniqueIdentifier(), JDIDebugBreakpointMessages.ConditionalBreakpointHandler_0, e)));
 						return SUSPEND;
 					}
 				}
 				return listener.getVote();
 			} catch (CoreException e) {
 				DebugException de = null;
 				if (e instanceof DebugException) {
 					de = (DebugException) e;
 				} else {
 					de = new DebugException(e.getStatus());
 				}
 				fireConditionHasRuntimeErrors(lineBreakpoint, de);
 			}
 		}
 		return SUSPEND;
 	}

 	public void breakpointInstalled(IJavaDebugTarget target, IJavaBreakpoint breakpoint) {
 	}

 	public void breakpointRemoved(IJavaDebugTarget target, IJavaBreakpoint breakpoint) {
 	}

 	public int installingBreakpoint(IJavaDebugTarget target, IJavaBreakpoint breakpoint, IJavaType type) {
 		return 0;
 	}

 	/**
 	 * Returns an evaluation engine for evaluating this breakpoint's condition
 	 * in the given target and project context.
 	 */
 	private IAstEvaluationEngine getEvaluationEngine(IJavaDebugTarget vm, IJavaProject project)   {
 		return ((JDIDebugTarget)vm).getEvaluationEngine(project);
 	}

 	private void fireConditionHasRuntimeErrors(IJavaLineBreakpoint breakpoint, DebugException exception) {
 		fHasErrors = true;
 		JDIDebugPlugin.getDefault().fireBreakpointHasRuntimeException(breakpoint, exception);
 	}

 	/**
 	 * Notifies listeners that a conditional breakpoint expression has been
 	 * compiled that contains errors
 	 */
 	private void fireConditionHasErrors(IJavaLineBreakpoint breakpoint, Message[] messages) {
 		fHasErrors = true;
 		JDIDebugPlugin.getDefault().fireBreakpointHasCompilationErrors(breakpoint, messages);
 	}

 	/**
 	 * Convert an array of <code>String</code> to an array of
 	 * <code>Message</code>.
 	 */
 	private Message[] getMessages(ICompiledExpression expression) {
 		String[] errorMessages= expression.getErrorMessages();
 		Message[] messages= new Message[errorMessages.length];
 		for (int i= 0; i < messages.length; i++) {
 			messages[i]= new Message(errorMessages[i], -1);
 		}
 		return messages;
 	}

 	/**
 	 * Returns whether errors were encountered when evaluating the condition (compilation or runtime).
 	 *
 	 * @return whether errors were encountered when evaluating the condition
 	 */
 	public boolean hasErrors() {
 		return fHasErrors;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2009 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jdt.internal.debug.core.breakpoints;

	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.debug.core.DebugEvent;
	import org.eclipse.debug.core.DebugException;
	import org.eclipse.debug.core.model.IDebugTarget;
	import org.eclipse.debug.core.model.IValue;
	import org.eclipse.jdt.core.IJavaProject;
	import org.eclipse.jdt.core.dom.Message;
	import org.eclipse.jdt.debug.core.IJavaBreakpoint;
	import org.eclipse.jdt.debug.core.IJavaBreakpointListener;
	import org.eclipse.jdt.debug.core.IJavaDebugTarget;
	import org.eclipse.jdt.debug.core.IJavaLineBreakpoint;
	import org.eclipse.jdt.debug.core.IJavaPrimitiveValue;
	import org.eclipse.jdt.debug.core.IJavaStackFrame;
	import org.eclipse.jdt.debug.core.IJavaThread;
	import org.eclipse.jdt.debug.core.IJavaType;
	import org.eclipse.jdt.debug.eval.IAstEvaluationEngine;
	import org.eclipse.jdt.debug.eval.ICompiledExpression;
	import org.eclipse.jdt.debug.eval.IEvaluationListener;
	import org.eclipse.jdt.debug.eval.IEvaluationResult;
	import org.eclipse.jdt.internal.debug.core.JDIDebugPlugin;
	import org.eclipse.jdt.internal.debug.core.model.JDIDebugTarget;
	import org.eclipse.jdt.internal.debug.core.model.JDIThread;

	import com.ibm.icu.text.MessageFormat;
	import com.sun.jdi.VMDisconnectedException;

	/**
	* Breakpoint listener to handle breakpoint conditions.
	*
	* @since 3.5
	*/
	public class ConditionalBreakpointHandler implements IJavaBreakpointListener {

	/**
	* Whether the condition had compile or runtime errors
	*/
	private boolean fHasErrors = false;

	/**
	* Listens for evaluation completion for condition evaluation.
	* If an evaluation evaluates <code>true</code> or has an error, this breakpoint
	* will suspend the thread in which the breakpoint was hit.
	* If the evaluation returns <code>false</code>, the thread is resumed.
	*/
	class EvaluationListener implements IEvaluationListener {

	/**
	* Lock for synchronizing evaluation
	*/
	private Object fLock = new Object();

	/**
	* The breakpoint that was hit
	*/
	private JavaLineBreakpoint fBreakpoint;

	/**
	* Result of the vote
	*/
	private int fVote;

	EvaluationListener(JavaLineBreakpoint breakpoint) {
	fBreakpoint = breakpoint;
	}

	public void evaluationComplete(IEvaluationResult result) {
	fVote = determineVote(result);
	synchronized (fLock) {
	fLock.notifyAll();
	}
	}

	/**
	* Processes the result to determine whether to suspend or resume.
	*
	* @param result evaluation result
	* @return vote
	*/
	private int determineVote(IEvaluationResult result) {
	if (result.isTerminated()) {
	// indicates the user terminated the evaluation
	return SUSPEND;
	}
	JDIThread thread= (JDIThread)result.getThread();
	if (result.hasErrors()) {
	DebugException exception= result.getException();
	Throwable wrappedException= exception.getStatus().getException();
	if (wrappedException instanceof VMDisconnectedException) {
	// VM terminated/disconnected during evaluation
	return DONT_SUSPEND;
	} else {
	fireConditionHasRuntimeErrors(fBreakpoint, exception);
	return SUSPEND;
	}
	} else {
	try {
	IValue value= result.getValue();
	if (fBreakpoint.isConditionSuspendOnTrue()) {
	if (value instanceof IJavaPrimitiveValue) {
	// Suspend when the condition evaluates true
	IJavaPrimitiveValue javaValue= (IJavaPrimitiveValue)value;
	if (javaValue.getJavaType().getName().equals("boolean")) { //$NON-NLS-1$
	if (javaValue.getBooleanValue()) {
	return SUSPEND;
	} else {
	return DONT_SUSPEND;
	}
	}
	}
	// result was not boolean
	fireConditionHasRuntimeErrors(fBreakpoint, new DebugException(
	new Status(IStatus.ERROR, JDIDebugPlugin.getUniqueIdentifier(),
	MessageFormat.format(JDIDebugBreakpointMessages.ConditionalBreakpointHandler_1, new String[]{value.getReferenceTypeName()}))));
	return SUSPEND;
	} else {
	IDebugTarget debugTarget= thread.getDebugTarget();
	IValue lastValue= fBreakpoint.setCurrentConditionValue(debugTarget, value);
	if (!value.equals(lastValue)) {
	return SUSPEND;
	} else {
	return DONT_SUSPEND;
	}
	}
	} catch (DebugException e) {
	// Suspend when an error occurs
	JDIDebugPlugin.log(e);
	return SUSPEND;
	}
	}
	}

	/**
	* Result of the conditional expression evaluation - to resume or not resume, that
	* is the question.
	*
	* @return vote result
	*/
	int getVote() {
	return fVote;
	}

	/**
	* Returns the lock object to synchronize this evaluation.
	*
	* @return lock object
	*/
	Object getLock() {
	return fLock;
	}
	}

	public void addingBreakpoint(IJavaDebugTarget target, IJavaBreakpoint breakpoint) {
	}

	public void breakpointHasCompilationErrors(IJavaLineBreakpoint breakpoint, Message[] errors) {
	}

	public void breakpointHasRuntimeException(IJavaLineBreakpoint breakpoint, DebugException exception) {
	}

	public int breakpointHit(IJavaThread thread, IJavaBreakpoint breakpoint) {
	if (breakpoint instanceof IJavaLineBreakpoint) {
	JavaLineBreakpoint lineBreakpoint = (JavaLineBreakpoint) breakpoint;
	try {
	final String condition= lineBreakpoint.getCondition();
	if (condition == null) {
	return SUSPEND;
	}
	EvaluationListener listener= new EvaluationListener(lineBreakpoint);
	IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
	IJavaProject project= lineBreakpoint.getJavaProject(frame);
	if (project == null) {
	fireConditionHasErrors(lineBreakpoint, new Message[]{new Message(JDIDebugBreakpointMessages.JavaLineBreakpoint_Unable_to_compile_conditional_breakpoint___missing_Java_project_context__1, -1)});
	return SUSPEND;
	}
	IJavaDebugTarget target = (IJavaDebugTarget) thread.getDebugTarget();
	IAstEvaluationEngine engine = getEvaluationEngine(target, project);
	if (engine == null) {
	// If no engine is available, suspend
	return SUSPEND;
	}
	ICompiledExpression expression= lineBreakpoint.getExpression(thread);
	if (expression == null) {
	expression= engine.getCompiledExpression(condition, frame);
	lineBreakpoint.setExpression(thread, expression);
	}
	if (expression.hasErrors()) {
	fireConditionHasErrors(lineBreakpoint, getMessages(expression));
	return SUSPEND;
	}
	Object lock = listener.getLock();
	synchronized (lock) {
	engine.evaluateExpression(expression, frame, listener, DebugEvent.EVALUATION_IMPLICIT, false);
	// TODO: timeout?
	try {
	lock.wait();
	} catch (InterruptedException e) {
	fireConditionHasRuntimeErrors(lineBreakpoint, new DebugException(
	new Status(IStatus.ERROR, JDIDebugPlugin.getUniqueIdentifier(), JDIDebugBreakpointMessages.ConditionalBreakpointHandler_0, e)));
	return SUSPEND;
	}
	}
	return listener.getVote();
	} catch (CoreException e) {
	DebugException de = null;
	if (e instanceof DebugException) {
	de = (DebugException) e;
	} else {
	de = new DebugException(e.getStatus());
	}
	fireConditionHasRuntimeErrors(lineBreakpoint, de);
	}
	}
	return SUSPEND;
	}

	public void breakpointInstalled(IJavaDebugTarget target, IJavaBreakpoint breakpoint) {
	}

	public void breakpointRemoved(IJavaDebugTarget target, IJavaBreakpoint breakpoint) {
	}

	public int installingBreakpoint(IJavaDebugTarget target, IJavaBreakpoint breakpoint, IJavaType type) {
	return 0;
	}

	/**
	* Returns an evaluation engine for evaluating this breakpoint's condition
	* in the given target and project context.
	*/
	private IAstEvaluationEngine getEvaluationEngine(IJavaDebugTarget vm, IJavaProject project) {
	return ((JDIDebugTarget)vm).getEvaluationEngine(project);
	}

	private void fireConditionHasRuntimeErrors(IJavaLineBreakpoint breakpoint, DebugException exception) {
	fHasErrors = true;
	JDIDebugPlugin.getDefault().fireBreakpointHasRuntimeException(breakpoint, exception);
	}

	/**
	* Notifies listeners that a conditional breakpoint expression has been
	* compiled that contains errors
	*/
	private void fireConditionHasErrors(IJavaLineBreakpoint breakpoint, Message[] messages) {
	fHasErrors = true;
	JDIDebugPlugin.getDefault().fireBreakpointHasCompilationErrors(breakpoint, messages);
	}

	/**
	* Convert an array of <code>String</code> to an array of
	* <code>Message</code>.
	*/
	private Message[] getMessages(ICompiledExpression expression) {
	String[] errorMessages= expression.getErrorMessages();
	Message[] messages= new Message[errorMessages.length];
	for (int i= 0; i < messages.length; i++) {
	messages[i]= new Message(errorMessages[i], -1);
	}
	return messages;
	}

	/**
	* Returns whether errors were encountered when evaluating the condition (compilation or runtime).
	*
	* @return whether errors were encountered when evaluating the condition
	*/
	public boolean hasErrors() {
	return fHasErrors;
	}
	}