bundles/org.eclipse.wst.xsl.jaxp.debug/src/org/eclipse/wst/xsl/jaxp/debug/debugger/AbstractDebugger.java - gerrit/sourceediting/webtools.sourceediting.xsl - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007, 2010 Chase Technology Ltd - http://www.chasetechnology.co.uk
  * 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:
  *     Doug Satchwell (Chase Technology Ltd) - initial API and implementation
  *     David Carver (Intalio) - cleanup findbug errors.
  *******************************************************************************/
 package org.eclipse.wst.xsl.jaxp.debug.debugger;

 import java.io.IOException;
 import java.io.Writer;
 import java.net.URL;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Set;
 import java.util.Stack;

 import javax.xml.transform.Result;
 import javax.xml.transform.stream.StreamResult;

 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.eclipse.wst.xsl.jaxp.debug.invoker.IProcessorInvoker;
 import org.eclipse.wst.xsl.jaxp.debug.invoker.TransformationException;

 /**
  * An implementation of <code>IXSLDebugger</code>.
  *
  * This class can be subclassed in order to provide debugging for a particular
  * XSLT processor.
  *
  * @author Doug Satchwell
  */
 public abstract class AbstractDebugger implements IXSLDebugger {
 	private static final Log log = LogFactory.getLog(AbstractDebugger.class);

 	private static final int ACTION_DO_NOTHING = 0;
 	private static final int ACTION_STOP = 1;
 	private static final int ACTION_QUIT = 2;
 	private static final int ACTION_SUSPEND = 3;
 	private static final int ACTION_RESUME = 4;
 	private static final int ACTION_STEP_INTO = 5;
 	private static final int ACTION_STEP_OVER = 6;
 	private static final int ACTION_STEP_RETURN = 7;

 	private static final String EVENT_STARTED = "started"; //$NON-NLS-1$
 	private static final String EVENT_STOPPED = "stopped"; //$NON-NLS-1$
 	private static final String EVENT_SUSPENDED = "suspended client"; //$NON-NLS-1$
 	private static final String EVENT_SUSPENDED_STEP = "suspended step"; //$NON-NLS-1$
 	private static final String EVENT_RESUMED = "resumed client"; //$NON-NLS-1$
 	private static final String EVENT_RESUMED_STEP = "resumed step"; //$NON-NLS-1$

 	private IProcessorInvoker invoker;
 	private int action;
 	private Writer eventWriter;
 	private Writer generatedWriter;
 	private final Set<BreakPoint> breakpoints = Collections
 			.synchronizedSet(new HashSet<BreakPoint>());
 	private final Stack<StyleFrame> stack = new Stack<StyleFrame>();
 	private StyleFrame stepOverFrame;
 	private BreakPoint breakpoint;
 	private URL sourceURL;
 	private Result result;

 	private int stepOverStackSize;

 	public synchronized void setInvoker(IProcessorInvoker invoker) {
 		this.invoker = invoker;
 	}

 	public synchronized void setEventWriter(Writer writer) {
 		eventWriter = writer;
 	}

 	public void setGeneratedWriter(Writer writer) {
 		this.generatedWriter = writer;
 	}

 	public synchronized void setSource(URL sourceURL) {
 		this.sourceURL = sourceURL;
 	}

 	public synchronized void setTarget(final Writer writer) {
 		result = new StreamResult(new Writer() {
 			public void write(char[] cbuf, int off, int len) throws IOException {
 				writer.write(cbuf, off, len);
 				generatedWriter.write(cbuf, off, len);
 			}

 			public void close() throws IOException {
 				writer.close();
 				generatedWriter.close();
 			}

 			public void flush() throws IOException {
 				writer.flush();
 				generatedWriter.flush();
 			}
 		});
 	}

 	public synchronized void run() {
 		if (action != ACTION_QUIT) {
 			debuggerStarted();
 			try {
 				invoker.transform(sourceURL, result);
 			} catch (TransformationException e) {
 				log.error("Transform failed", e); //$NON-NLS-1$
 			}
 			debuggerStopped();
 		}
 	}

 	public synchronized void suspend() {
 		action = ACTION_SUSPEND;
 		notify();
 	}

 	public synchronized void resume() {
 		action = ACTION_RESUME;
 		notify();
 	}

 	public synchronized void stepInto() {
 		action = ACTION_STEP_INTO;
 		notify();
 	}

 	public synchronized void stepOver() {
 		action = ACTION_STEP_OVER;
 		stepOverFrame = peekStyleFrame();
 		stepOverStackSize = stack.size();
 		notify();
 	}

 	public synchronized void stepReturn() {
 		action = ACTION_STEP_RETURN;
 		stepOverStackSize = stack.size();
 		notify();
 	}

 	public synchronized void quit() {
 		action = ACTION_QUIT;
 	}

 	public String stack() {
 		StringBuffer sb = new StringBuffer();
 		synchronized (stack) {
 			for (Iterator<StyleFrame> iter = stack.iterator(); iter.hasNext();) {
 				StyleFrame frame = (StyleFrame) iter.next();
 				sb.append(frame.toString());
 				for (Iterator<?> iter2 = frame.getVariableStack().iterator(); iter2
 						.hasNext();) {
 					sb.append("|"); //$NON-NLS-1$
 					Variable v = (Variable) iter2.next();
 					sb.append(v.getId());
 				}
 				if (iter.hasNext())
 					sb.append("$$$"); //$NON-NLS-1$
 			}
 		}
 		return sb.toString();
 	}

 	/**
 	 * Check whether the debugger has been stopped and perform the appropriate
 	 * action if so.
 	 */
 	public synchronized void checkStopped() {
 		if (action == ACTION_QUIT)
 			debuggerQuit();
 		else if (action == ACTION_STOP)
 			debuggerStopped();
 	}

 	/**
 	 * Check whether the debugger is currently suspended or stepping at the
 	 * given breakpoint and style frame, and perform the appropriate action if
 	 * so.
 	 *
 	 * @param styleFrame
 	 *            the styleframe to check
 	 * @param breakpoint
 	 *            the current location
 	 */
 	public synchronized void checkSuspended(StyleFrame styleFrame,
 			BreakPoint breakpoint) {
 		// do not suspend unless the line actually changed
 		if (breakpoint.equals(this.breakpoint))
 			return;
 		int stackSize;
 		synchronized (stack) {
 			stackSize = stack.size();
 		}
 		// do not suspend if there is nothing in the stack
 		if (stackSize == 0)
 			return;
 		switch (action) {
 		case ACTION_SUSPEND:
 			debuggerSuspendedClient(breakpoint);
 			break;
 		case ACTION_STEP_OVER:
 			// suspend if we are in the same template or we are moving up the
 			// stack
 			if (styleFrame.equals(stepOverFrame)
 					|| stackSize < stepOverStackSize)
 				debuggerSuspendedStep(breakpoint);
 			break;
 		case ACTION_STEP_INTO:
 			debuggerSuspendedStep(breakpoint);
 			break;
 		case ACTION_STEP_RETURN:
 			// suspend if we moved up the stack
 			if (stackSize < stepOverStackSize)
 				debuggerSuspendedStep(breakpoint);
 			break;
 		default:
 			checkBreakpoint(breakpoint);
 		}
 	}

 	private synchronized void checkBreakpoint(BreakPoint breakpoint) {
 		if (isBreakpoint(breakpoint))
 			debuggerSuspendedBreakpoint(breakpoint);
 	}

 	/**
 	 * Called when the next transform in the pipeline has begun.
 	 */
 	public synchronized void debuggerTransformStarted() {
 		stack.clear();
 	}

 	protected synchronized void debuggerStarted() {
 		action = ACTION_DO_NOTHING;
 		sendEvent(EVENT_STARTED);
 	}

 	protected synchronized void debuggerStopped() {
 		action = ACTION_DO_NOTHING;
 		sendEvent(EVENT_STOPPED);
 	}

 	private synchronized void debuggerQuit() {
 		// just wait here indefinitely until the JVM exists, just to make sure
 		// we don't send any further events
 		try {
 			wait();
 		} catch (InterruptedException e) {
 		}
 	}

 	private synchronized void debuggerSuspendedBreakpoint(BreakPoint breakpoint) {
 		sendEvent("suspended breakpoint " + breakpoint); //$NON-NLS-1$
 		debuggerSuspended(breakpoint);
 	}

 	private synchronized void debuggerSuspendedStep(BreakPoint breakpoint) {
 		sendEvent(EVENT_SUSPENDED_STEP);
 		debuggerSuspended(breakpoint);
 	}

 	private synchronized void debuggerSuspendedClient(BreakPoint breakpoint) {
 		sendEvent(EVENT_SUSPENDED);
 		debuggerSuspended(breakpoint);
 	}

 	public synchronized void debuggerSuspended(BreakPoint breakpoint) {
 		this.breakpoint = breakpoint;
 		do {
 			try {
 				wait();
 			} catch (InterruptedException e) {
 			}
 		} while (action != ACTION_RESUME && action != ACTION_STEP_INTO
 				&& action != ACTION_STEP_OVER && action != ACTION_STEP_RETURN
 				&& action != ACTION_STOP);
 		debuggerResumed();
 	}

 	private synchronized void debuggerResumed() {
 		if (action == ACTION_STEP_INTO || action == ACTION_STEP_OVER
 				|| action == ACTION_STEP_RETURN)
 			sendEvent(EVENT_RESUMED_STEP);
 		else
 			sendEvent(EVENT_RESUMED);
 	}

 	private synchronized void sendEvent(String event) {
 		try {
 			log.info("Sending event: " + event + " eventWriter=" + eventWriter); //$NON-NLS-1$//$NON-NLS-2$
 			eventWriter.write(event + "\n"); //$NON-NLS-1$
 			eventWriter.flush();
 		} catch (IOException e) {
 			log.error("Error sending event", e); //$NON-NLS-1$
 		}
 	}

 	public void addBreakpoint(BreakPoint breakpoint) {
 		log.info("Adding breakpoint: " + breakpoint); //$NON-NLS-1$
 		breakpoints.add(breakpoint);
 	}

 	public void removeBreakpoint(BreakPoint breakpoint) {
 		log.info("Removing breakpoint: " + breakpoint); //$NON-NLS-1$
 		breakpoints.remove(breakpoint);
 	}

 	private boolean isBreakpoint(BreakPoint breakpoint) {
 		// do not check for breakpoint unless the line or filename actually
 		// changed
 		if (breakpoint.equals(this.breakpoint))
 			return false;
 		this.breakpoint = null;
 		return breakpoints.contains(breakpoint);
 	}

 	/**
 	 * Pop a style frame from the stack.
 	 *
 	 * @return the popped style frame
 	 */
 	public StyleFrame popStyleFrame() {
 		synchronized (stack) {
 			StyleFrame styleFrame = (StyleFrame) stack.pop();
 			if (styleFrame.getParent() != null)
 				styleFrame.getParent().removeChild(styleFrame);
 			log
 					.trace("Popped frame: " + styleFrame + " (size after pop=" + stack.size() + ")"); //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
 			return styleFrame;
 		}
 	}

 	/**
 	 * Push a style frame onto the stack.
 	 *
 	 * @param styleFrame
 	 */
 	public void pushStyleFrame(StyleFrame styleFrame) {
 		synchronized (stack) {
 			stack.push(styleFrame);
 			log
 					.trace("Pushed frame: " + styleFrame + " (size after push=" + stack.size() + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
 		}
 	}

 	/**
 	 * Peek a style frame from the stack.
 	 *
 	 * @return the peeked style frame
 	 */
 	public StyleFrame peekStyleFrame() {
 		synchronized (stack) {
 			if (stack.size() > 0)
 				return (StyleFrame) stack.peek();
 			return null;
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2007, 2010 Chase Technology Ltd - http://www.chasetechnology.co.uk
	* 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:
	* Doug Satchwell (Chase Technology Ltd) - initial API and implementation
	* David Carver (Intalio) - cleanup findbug errors.
	*******************************************************************************/
	package org.eclipse.wst.xsl.jaxp.debug.debugger;

	import java.io.IOException;
	import java.io.Writer;
	import java.net.URL;
	import java.util.Collections;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.Set;
	import java.util.Stack;

	import javax.xml.transform.Result;
	import javax.xml.transform.stream.StreamResult;

	import org.apache.commons.logging.Log;
	import org.apache.commons.logging.LogFactory;
	import org.eclipse.wst.xsl.jaxp.debug.invoker.IProcessorInvoker;
	import org.eclipse.wst.xsl.jaxp.debug.invoker.TransformationException;

	/**
	* An implementation of <code>IXSLDebugger</code>.
	*
	* This class can be subclassed in order to provide debugging for a particular
	* XSLT processor.
	*
	* @author Doug Satchwell
	*/
	public abstract class AbstractDebugger implements IXSLDebugger {
	private static final Log log = LogFactory.getLog(AbstractDebugger.class);

	private static final int ACTION_DO_NOTHING = 0;
	private static final int ACTION_STOP = 1;
	private static final int ACTION_QUIT = 2;
	private static final int ACTION_SUSPEND = 3;
	private static final int ACTION_RESUME = 4;
	private static final int ACTION_STEP_INTO = 5;
	private static final int ACTION_STEP_OVER = 6;
	private static final int ACTION_STEP_RETURN = 7;

	private static final String EVENT_STARTED = "started"; //$NON-NLS-1$
	private static final String EVENT_STOPPED = "stopped"; //$NON-NLS-1$
	private static final String EVENT_SUSPENDED = "suspended client"; //$NON-NLS-1$
	private static final String EVENT_SUSPENDED_STEP = "suspended step"; //$NON-NLS-1$
	private static final String EVENT_RESUMED = "resumed client"; //$NON-NLS-1$
	private static final String EVENT_RESUMED_STEP = "resumed step"; //$NON-NLS-1$

	private IProcessorInvoker invoker;
	private int action;
	private Writer eventWriter;
	private Writer generatedWriter;
	private final Set<BreakPoint> breakpoints = Collections
	.synchronizedSet(new HashSet<BreakPoint>());
	private final Stack<StyleFrame> stack = new Stack<StyleFrame>();
	private StyleFrame stepOverFrame;
	private BreakPoint breakpoint;
	private URL sourceURL;
	private Result result;

	private int stepOverStackSize;

	public synchronized void setInvoker(IProcessorInvoker invoker) {
	this.invoker = invoker;
	}

	public synchronized void setEventWriter(Writer writer) {
	eventWriter = writer;
	}

	public void setGeneratedWriter(Writer writer) {
	this.generatedWriter = writer;
	}

	public synchronized void setSource(URL sourceURL) {
	this.sourceURL = sourceURL;
	}

	public synchronized void setTarget(final Writer writer) {
	result = new StreamResult(new Writer() {
	public void write(char[] cbuf, int off, int len) throws IOException {
	writer.write(cbuf, off, len);
	generatedWriter.write(cbuf, off, len);
	}

	public void close() throws IOException {
	writer.close();
	generatedWriter.close();
	}

	public void flush() throws IOException {
	writer.flush();
	generatedWriter.flush();
	}
	});
	}

	public synchronized void run() {
	if (action != ACTION_QUIT) {
	debuggerStarted();
	try {
	invoker.transform(sourceURL, result);
	} catch (TransformationException e) {
	log.error("Transform failed", e); //$NON-NLS-1$
	}
	debuggerStopped();
	}
	}

	public synchronized void suspend() {
	action = ACTION_SUSPEND;
	notify();
	}

	public synchronized void resume() {
	action = ACTION_RESUME;
	notify();
	}

	public synchronized void stepInto() {
	action = ACTION_STEP_INTO;
	notify();
	}

	public synchronized void stepOver() {
	action = ACTION_STEP_OVER;
	stepOverFrame = peekStyleFrame();
	stepOverStackSize = stack.size();
	notify();
	}

	public synchronized void stepReturn() {
	action = ACTION_STEP_RETURN;
	stepOverStackSize = stack.size();
	notify();
	}

	public synchronized void quit() {
	action = ACTION_QUIT;
	}

	public String stack() {
	StringBuffer sb = new StringBuffer();
	synchronized (stack) {
	for (Iterator<StyleFrame> iter = stack.iterator(); iter.hasNext();) {
	StyleFrame frame = (StyleFrame) iter.next();
	sb.append(frame.toString());
	for (Iterator<?> iter2 = frame.getVariableStack().iterator(); iter2
	.hasNext();) {
	sb.append("\|"); //$NON-NLS-1$
	Variable v = (Variable) iter2.next();
	sb.append(v.getId());
	}
	if (iter.hasNext())
	sb.append("$$$"); //$NON-NLS-1$
	}
	}
	return sb.toString();
	}

	/**
	* Check whether the debugger has been stopped and perform the appropriate
	* action if so.
	*/
	public synchronized void checkStopped() {
	if (action == ACTION_QUIT)
	debuggerQuit();
	else if (action == ACTION_STOP)
	debuggerStopped();
	}

	/**
	* Check whether the debugger is currently suspended or stepping at the
	* given breakpoint and style frame, and perform the appropriate action if
	* so.
	*
	* @param styleFrame
	* the styleframe to check
	* @param breakpoint
	* the current location
	*/
	public synchronized void checkSuspended(StyleFrame styleFrame,
	BreakPoint breakpoint) {
	// do not suspend unless the line actually changed
	if (breakpoint.equals(this.breakpoint))
	return;
	int stackSize;
	synchronized (stack) {
	stackSize = stack.size();
	}
	// do not suspend if there is nothing in the stack
	if (stackSize == 0)
	return;
	switch (action) {
	case ACTION_SUSPEND:
	debuggerSuspendedClient(breakpoint);
	break;
	case ACTION_STEP_OVER:
	// suspend if we are in the same template or we are moving up the
	// stack
	if (styleFrame.equals(stepOverFrame)
	\|\| stackSize < stepOverStackSize)
	debuggerSuspendedStep(breakpoint);
	break;
	case ACTION_STEP_INTO:
	debuggerSuspendedStep(breakpoint);
	break;
	case ACTION_STEP_RETURN:
	// suspend if we moved up the stack
	if (stackSize < stepOverStackSize)
	debuggerSuspendedStep(breakpoint);
	break;
	default:
	checkBreakpoint(breakpoint);
	}
	}

	private synchronized void checkBreakpoint(BreakPoint breakpoint) {
	if (isBreakpoint(breakpoint))
	debuggerSuspendedBreakpoint(breakpoint);
	}

	/**
	* Called when the next transform in the pipeline has begun.
	*/
	public synchronized void debuggerTransformStarted() {
	stack.clear();
	}

	protected synchronized void debuggerStarted() {
	action = ACTION_DO_NOTHING;
	sendEvent(EVENT_STARTED);
	}

	protected synchronized void debuggerStopped() {
	action = ACTION_DO_NOTHING;
	sendEvent(EVENT_STOPPED);
	}

	private synchronized void debuggerQuit() {
	// just wait here indefinitely until the JVM exists, just to make sure
	// we don't send any further events
	try {
	wait();
	} catch (InterruptedException e) {
	}
	}

	private synchronized void debuggerSuspendedBreakpoint(BreakPoint breakpoint) {
	sendEvent("suspended breakpoint " + breakpoint); //$NON-NLS-1$
	debuggerSuspended(breakpoint);
	}

	private synchronized void debuggerSuspendedStep(BreakPoint breakpoint) {
	sendEvent(EVENT_SUSPENDED_STEP);
	debuggerSuspended(breakpoint);
	}

	private synchronized void debuggerSuspendedClient(BreakPoint breakpoint) {
	sendEvent(EVENT_SUSPENDED);
	debuggerSuspended(breakpoint);
	}

	public synchronized void debuggerSuspended(BreakPoint breakpoint) {
	this.breakpoint = breakpoint;
	do {
	try {
	wait();
	} catch (InterruptedException e) {
	}
	} while (action != ACTION_RESUME && action != ACTION_STEP_INTO
	&& action != ACTION_STEP_OVER && action != ACTION_STEP_RETURN
	&& action != ACTION_STOP);
	debuggerResumed();
	}

	private synchronized void debuggerResumed() {
	if (action == ACTION_STEP_INTO \|\| action == ACTION_STEP_OVER
	\|\| action == ACTION_STEP_RETURN)
	sendEvent(EVENT_RESUMED_STEP);
	else
	sendEvent(EVENT_RESUMED);
	}

	private synchronized void sendEvent(String event) {
	try {
	log.info("Sending event: " + event + " eventWriter=" + eventWriter); //$NON-NLS-1$//$NON-NLS-2$
	eventWriter.write(event + "\n"); //$NON-NLS-1$
	eventWriter.flush();
	} catch (IOException e) {
	log.error("Error sending event", e); //$NON-NLS-1$
	}
	}

	public void addBreakpoint(BreakPoint breakpoint) {
	log.info("Adding breakpoint: " + breakpoint); //$NON-NLS-1$
	breakpoints.add(breakpoint);
	}

	public void removeBreakpoint(BreakPoint breakpoint) {
	log.info("Removing breakpoint: " + breakpoint); //$NON-NLS-1$
	breakpoints.remove(breakpoint);
	}

	private boolean isBreakpoint(BreakPoint breakpoint) {
	// do not check for breakpoint unless the line or filename actually
	// changed
	if (breakpoint.equals(this.breakpoint))
	return false;
	this.breakpoint = null;
	return breakpoints.contains(breakpoint);
	}

	/**
	* Pop a style frame from the stack.
	*
	* @return the popped style frame
	*/
	public StyleFrame popStyleFrame() {
	synchronized (stack) {
	StyleFrame styleFrame = (StyleFrame) stack.pop();
	if (styleFrame.getParent() != null)
	styleFrame.getParent().removeChild(styleFrame);
	log
	.trace("Popped frame: " + styleFrame + " (size after pop=" + stack.size() + ")"); //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
	return styleFrame;
	}
	}

	/**
	* Push a style frame onto the stack.
	*
	* @param styleFrame
	*/
	public void pushStyleFrame(StyleFrame styleFrame) {
	synchronized (stack) {
	stack.push(styleFrame);
	log
	.trace("Pushed frame: " + styleFrame + " (size after push=" + stack.size() + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	}
	}

	/**
	* Peek a style frame from the stack.
	*
	* @return the peeked style frame
	*/
	public StyleFrame peekStyleFrame() {
	synchronized (stack) {
	if (stack.size() > 0)
	return (StyleFrame) stack.peek();
	return null;
	}
	}
	}