org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/breakpoints/ConditionalBreakpointHandler.java

/*******************************************************************************
 * Copyright (c) 2009, 2017 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.IJavaObject;
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.JDINullValue;
import org.eclipse.jdt.internal.debug.core.model.JDIThread;
import org.eclipse.jdt.internal.debug.core.model.JDIValue;

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;
		}

		@Override
		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;
				} 
				fireConditionHasRuntimeErrors(fBreakpoint, exception);
				return SUSPEND;
			} 
			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;
							} 
							return DONT_SUSPEND;
						}
					}
					if ((value instanceof JDIValue) && !(value instanceof JDINullValue)) {
						JDIValue jdiValue = (JDIValue)value;
						// Suspend if return is Boolean(true) else don't suspend (no error dialog)
						if (jdiValue.getJavaType().getName().equals("java.lang.Boolean")) {//$NON-NLS-1$
							IJavaPrimitiveValue javaValue = (IJavaPrimitiveValue) ((IJavaObject) jdiValue).getField("value", false).getValue(); //$NON-NLS-1$
							if (javaValue.getBooleanValue()) {
								return SUSPEND;
							}
							return DONT_SUSPEND;
						}
						return DONT_SUSPEND;
					}
					IStatus status = new Status(
							IStatus.ERROR,
							JDIDebugPlugin.getUniqueIdentifier(),
							MessageFormat.format(JDIDebugBreakpointMessages.ConditionalBreakpointHandler_1, value.getReferenceTypeName()));
					// result was not JDIValue
					fireConditionHasRuntimeErrors(fBreakpoint, new DebugException(status));
					return SUSPEND;
				} 
				IDebugTarget debugTarget = thread.getDebugTarget();
				IValue lastValue = fBreakpoint
						.setCurrentConditionValue(debugTarget, value);
				if (!value.equals(lastValue)) {
					return SUSPEND;
				} 
				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;
		}
	}

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

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

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

	@Override
	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;
	}

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

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

	@Override
	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.
	 * @param vm the VM to get an evaluation engine for
	 * @param project the project context
	 * @return a new {@link IAstEvaluationEngine}
	 */
	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
	 * @param breakpoint the breakpoint that has errors in its condition
	 * @param messages the error messages
	 */
	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>.
	 * @param expression the expression to get messages from
	 * @return the array of {@link Message}s from the expression
	 */
	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;
	}
}