plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/ExpressionProcesserController.java - gerrit/jeetools/webtools.javaee - Git at Google

 /*******************************************************************************
  * Copyright (c) 2004 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
  *******************************************************************************/
 /*
  *  $RCSfile: ExpressionProcesserController.java,v $
  *  $Revision: 1.5 $  $Date: 2005/02/15 22:57:54 $
  */
 package org.eclipse.jem.internal.proxy.vm.remote;

 import java.io.DataInputStream;
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.util.Arrays;
 import java.util.List;

 import org.eclipse.jem.internal.proxy.common.*;
 import org.eclipse.jem.internal.proxy.common.CommandException;
 import org.eclipse.jem.internal.proxy.common.MapTypes;
 import org.eclipse.jem.internal.proxy.common.remote.Commands;
 import org.eclipse.jem.internal.proxy.common.remote.ExpressionCommands;
 import org.eclipse.jem.internal.proxy.initParser.EvaluationException;
 import org.eclipse.jem.internal.proxy.initParser.tree.ExpressionProcesser;
 import org.eclipse.jem.internal.proxy.initParser.tree.IInternalExpressionConstants;
 import org.eclipse.jem.internal.proxy.initParser.tree.IExpressionConstants.NoExpressionValueException;


 /**
  * This processes the commands for expression processing and sends them over
  * to the common expression processer.
  *
  * This will be instantiated on the start of an expression. And then
  * each expression request from the IDE will be sent into here. The
  * reason this guy doesn't hold onto the connection and process the
  * entire expression is because we need to return to the connection
  * handler to keep the connection live (there is timeouts and stuff
  * in there that we don't want to duplicate here).
  * <p>
  * If there are any expression processing errors (versus hard io errors) we
  * will save up the error but don't do any more processing other than to make
  * sure we read the complete subcommand. This is so that the inputstream is left
  * in a valid state without standed data.
  * <p>
  * The at the sync point (either get value or sync subcommand) we will send back
  * the error.
  *
  * @since 1.0.0
  */
 public class ExpressionProcesserController {

 	protected final RemoteVMServerThread server;
 	protected final ConnectionHandler connHandler;
 	protected final ExpressionProcesser exp;
 	protected Commands.ValueObject workerValue = new Commands.ValueObject();	// A worker value object so we don't need to keep creating them and releasing them.
 	private ClassLoader classLoader;

 	/**
 	 * An error has occurred. At this point all subcommands will simply make sure they flush the input stream
 	 * correctly, but they do not process it.
 	 *
 	 * @since 1.0.0
 	 */
 	protected boolean errorOccurred = false;

 	private String novalueMsg = null;	// If NoExpressionValueException then this is the msg.
 	private Throwable exception = null;	// Was there another kind of exception that was caught.

 	/**
 	 * Create with a default expression processer.
 	 * @param server
 	 *
 	 * @since 1.0.0
 	 */
 	public ExpressionProcesserController(RemoteVMServerThread server, ConnectionHandler connHandler) {
 		this(server, connHandler, new ExpressionProcesser());
 	}

 	/**
 	 * Create from a subclass with a given expression processer.
 	 *
 	 * @param server
 	 * @param exp
 	 *
 	 * @since 1.0.0
 	 */
 	protected ExpressionProcesserController(RemoteVMServerThread server, ConnectionHandler connHandler, ExpressionProcesser exp) {
 		this.server = server;
 		this.connHandler = connHandler;
 		this.exp = exp;
 	}

 	/**
 	 * Set the class loader to use for finding classes. If never set, or if <code>null</code>, then
 	 * <code>Class.forName</code> will be used.
 	 *
 	 * @param classLoader
 	 *
 	 * @since 1.0.0
 	 */
 	public void setClassLoader(ClassLoader classLoader) {
 		this.classLoader = classLoader;
 	}

 	/*
 	 * Array of primitive type names. Used to look up primtive types in primitive types array.
 	 *
 	 * @since 1.0.0
 	 */
 	private static final List PRIMITIVE_NAMES = Arrays.asList(new String[] {"byte", "char", "short", "int", "long", "float", "double"});
 	private static final Class[] PRIMITIVE_TYPES = new Class[] {Byte.TYPE, Character.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE, Float.TYPE, Double.TYPE};
 	/**
 	 * Load the class given the name. If not found, return null.
 	 *
 	 * @param className
 	 * @return
 	 *
 	 * @since 1.0.0
 	 */
 	protected Class loadClass(String className) throws ClassNotFoundException {
 		if (className == null)
 			return null;
 		else if (className.endsWith("[]")) {
 			// We have an array request instead. This is trickier.
 			return loadClass(MapTypes.getJNIFormatName(className));
 		} else {
 			int primIndex = PRIMITIVE_NAMES.indexOf(className);
 			if (primIndex >= 0)
 				return PRIMITIVE_TYPES[primIndex];
 			else if (classLoader == null) {
 				return Class.forName(className);
 			} else {
 				return classLoader.loadClass(className);
 			}
 		}
 	}

 	/**
 	 * Now process the input stream. If either throws occurs, this is a hard error and we must terminate
 	 * the entire connection. The input stream is in an unknown state.
 	 *
 	 * @param in The input stream to get the data for the current sub-command.
 	 *
 	 * @throws CommandException
 	 * @throws IOException
 	 * @since 1.0.0
 	 */
 	public void process(DataInputStream in) throws CommandException, IOException {
 		// In the following subcommand processing, we always read the entire subcommand from the stream.
 		// Then we check if an error has occurred in the past. If it has, we simply break. This is because
 		// once an error occurred we don't want to continue wasting time evaluating, however we need to make
 		// sure that the stream is read completely so that we don't have a corrupted input stream. That way
 		// when all is done we can return the error and still have a valid connection socket.
 		byte subcommand = in.readByte();
 		try {
 			switch (subcommand) {
 				case IInternalExpressionConstants.PUSH_TO_PROXY_EXPRESSION :
 					// Getting a proxy push. The value is sent as valueObject, so use that to read it in.
 					Commands.readValue(in, workerValue);
 					if (errorOccurred)
 						break;
 					Object value = connHandler.getInvokableObject(workerValue);
 					if (value == null)
 						exp.pushExpression(null, MethodHelper.NULL_TYPE);
 					else if (workerValue.isPrimitive())
 						exp.pushExpression(value, workerValue.getPrimitiveType());
 					else
 						exp.pushExpression(value, value.getClass());
 					break;

 				case IInternalExpressionConstants.CAST_EXPRESSION :
 					// Get a cast request. The type is sent as valueObject.
 					Commands.readValue(in, workerValue);
 					if (errorOccurred)
 						break;
 					value = connHandler.getInvokableObject(workerValue);
 					try {
 						if (value instanceof String)
 							value = loadClass((String) value);
 						exp.pushCast((Class) value);
 					} catch (NoExpressionValueException e) {
 						processException(e);
 					} catch (ClassNotFoundException e) {
 						processException(e);
 					}
 					break;

 				case IInternalExpressionConstants.INSTANCEOF_EXPRESSION :
 					// Get a instanceof request. The type is sent as valueObject.
 					Commands.readValue(in, workerValue);
 					if (errorOccurred)
 						break;
 					value = connHandler.getInvokableObject(workerValue);
 					try {
 						if (value instanceof String)
 							value = loadClass((String) value);
 						exp.pushInstanceof((Class) value);
 					} catch (ClassNotFoundException e) {
 						processException(e);
 					} catch (NoExpressionValueException e) {
 						processException(e);
 					}
 					break;

 				case IInternalExpressionConstants.INFIX_EXPRESSION :
 					// Get an infix request. The operator and operand type are sent as bytes.
 					byte infix_operator = in.readByte();
 					byte infix_operandType = in.readByte();
 					if (errorOccurred)
 						break;
 					try {
 						exp.pushInfix(infix_operator, infix_operandType);
 					} catch (NoExpressionValueException e1) {
 						processException(e1);
 					}
 					break;

 				case IInternalExpressionConstants.PREFIX_EXPRESSION :
 					// Get a prefix request. The operator is sent as byte.
 					byte prefix_operandType = in.readByte();
 					if (errorOccurred)
 						break;
 					try {
 						exp.pushPrefix(prefix_operandType);
 					} catch (NoExpressionValueException e2) {
 						processException(e2);
 					}
 					break;

 				case IInternalExpressionConstants.TYPELITERAL_EXPRESSION :
 					// Get a type literal request. The type string is sent as valueObject.
 					Commands.readValue(in, workerValue);
 					if (errorOccurred)
 						break;
 					value = connHandler.getInvokableObject(workerValue);
 					try {
 						value = loadClass((String) value);
 						exp.pushExpression((Class) value, Class.class);
 					} catch (ClassNotFoundException e) {
 						processException(e);
 					}
 					break;

 				case IInternalExpressionConstants.ARRAY_ACCESS_EXPRESSION :
 					// Get an array access request. The index cound is sent as int.
 					int arrayAccess_Indexcount = in.readInt();
 					if (errorOccurred)
 						break;
 					try {
 						exp.pushArrayAccess(arrayAccess_Indexcount);
 					} catch (NoExpressionValueException e3) {
 						processException(e3);
 					}
 					break;

 				case IInternalExpressionConstants.ARRAY_CREATION_EXPRESSION :
 					// Get an array creation request. The type is sent as valueObject, followed by int dimension count.
 					Commands.readValue(in, workerValue);
 					int arrayCreation_dimCount = in.readInt();
 					if (errorOccurred)
 						break;
 					value = connHandler.getInvokableObject(workerValue);
 					try {
 						if (value instanceof String)
 							value = loadClass((String) value);
 						exp.pushArrayCreation((Class) value, arrayCreation_dimCount);
 					} catch (ClassNotFoundException e) {
 						processException(e);
 					} catch (NoExpressionValueException e) {
 						processException(e);
 					}
 					break;

 				case IInternalExpressionConstants.ARRAY_INITIALIZER_EXPRESSION :
 					// Get an array initializer request. The type is sent as valueObject, followed by int expression count.
 					Commands.readValue(in, workerValue);
 					int arrayInitializer_expressionCount = in.readInt();
 					if (errorOccurred)
 						break;
 					value = connHandler.getInvokableObject(workerValue);
 					try {
 						if (value instanceof String)
 							value = loadClass((String) value);
 						exp.pushArrayInitializer((Class) value, arrayInitializer_expressionCount);
 					} catch (ClassNotFoundException e) {
 						processException(e);
 					} catch (NoExpressionValueException e) {
 						processException(e);
 					}
 					break;

 				case IInternalExpressionConstants.CLASS_INSTANCE_CREATION_EXPRESSION :
 					// Get a class instance creation request. The type is sent as valueObject, followed by int argument count.
 					Commands.readValue(in, workerValue);
 					int newInstance_argCount = in.readInt();
 					if (errorOccurred)
 						return;
 					value = connHandler.getInvokableObject(workerValue);
 					try {
 						if (value instanceof String)
 							value = loadClass((String) value);
 						exp.pushClassInstanceCreation((Class) value, newInstance_argCount);
 					} catch (ClassNotFoundException e) {
 						processException(e);
 					} catch (EvaluationException e) {
 						processException(e);
 					} catch (NoExpressionValueException e) {
 						processException(e);
 					} catch (InstantiationException e) {
 						processException(e);
 					} catch (IllegalAccessException e) {
 						processException(e);
 					} catch (InvocationTargetException e) {
 						processException(e);
 					} catch (LinkageError e) {
 						processError(e);
 					}
 					break;

 				case IInternalExpressionConstants.TYPERECEIVER_EXPRESSION :
 					// Get a type receiver request. The type is sent as valueObject.
 					Commands.readValue(in, workerValue);
 					if (errorOccurred)
 						break;
 					value = connHandler.getInvokableObject(workerValue);
 					try {
 						if (value instanceof String)
 							value = loadClass((String) value);
 						exp.pushExpression(value, (Class) value);
 					} catch (ClassNotFoundException e) {
 						processException(e);
 					}
 					break;

 				case IInternalExpressionConstants.FIELD_ACCESS_EXPRESSION :
 					// Get a field access request. The field name sent as string, followed by hasReceiver as boolean.
 					String fieldAccess_name = in.readUTF();
 					boolean fieldAccess_receiver = in.readBoolean();
 					if (errorOccurred)
 						break;
 					try {
 						exp.pushFieldAccess(fieldAccess_name, fieldAccess_receiver);
 					} catch (NoExpressionValueException e4) {
 						processException(e4);
 					} catch (NoSuchFieldException e4) {
 						processException(e4);
 					} catch (IllegalAccessException e4) {
 						processException(e4);
 					}
 					break;

 				case IInternalExpressionConstants.METHOD_EXPRESSION :
 					// Get a method invocation request. The method name sent as string, followed by hasReceiver as boolean, and argCount as int.
 					String method_name = in.readUTF();
 					boolean method_receiver = in.readBoolean();
 					int method_argCount = in.readInt();
 					if (errorOccurred)
 						break;
 					try {
 						exp.pushMethodInvocation(method_name, method_receiver, method_argCount);
 					} catch (EvaluationException e5) {
 						processException(e5);
 					} catch (NoExpressionValueException e5) {
 						processException(e5);
 					} catch (IllegalAccessException e5) {
 						processException(e5);
 					} catch (InvocationTargetException e5) {
 						processException(e5);
 					}
 					break;

 				case IInternalExpressionConstants.CONDITIONAL_EXPRESSION :
 					// Get a conditional expression request. The expression type (ie. condition/true/false) is sent as a byte
 					byte conditional_type = in.readByte();
 					if (errorOccurred)
 						break;
 					try {
 						exp.pushConditional(conditional_type);
 					} catch (NoExpressionValueException e6) {
 						processException(e6);
 					}
 					break;
 			}

 		} catch (RuntimeException e) {
 			processException(e);
 		}

 		workerValue.set();	// Clear it out so nothing being held onto.
 	}


 	/**
 	 * Pull the value. If an error occurred during this, then <code>null</code> is returned, and
 	 * caller should do normal error processing.
 	 *
 	 * @return r[0] is the value, r[1] is the type of the value. <code>null</code> if there was an error.
 	 *
 	 * @since 1.0.0
 	 */
 	public Object[] pullValue() {
 		Object[] result = new Object[2];
 		try {
 			exp.pullValue(result);
 			return result;
 		} catch (NoExpressionValueException e) {
 			processException(e);
 		}
 		return null;
 	}

 	/**
 	 * Process all other exceptions then the NoExpressionValueException, InvocationTargetException, and EvaluationException. This is
 	 * for exceptions that are not related to the input stream and shouldn't
 	 * cause the input stream to be closed.
 	 *
 	 * @param e
 	 *
 	 * @since 1.0.0
 	 */
 	protected final void processException(Exception e) {
 		// Process all other exceptions.
 		errorOccurred = true;
 		exception = e;
 	}

 	/**
 	 * Process certain errors. Should not be called for general errors. Should be called for specific java.lang.Errors that
 	 * are not related to the input stream and shouldn't cause the input stream to be closed.
 	 *
 	 * @param e
 	 *
 	 * @since 1.0.2
 	 */
 	protected final void processError(Error e) {
 		// Process specific errors
 		errorOccurred = true;
 		exception = e;
 	}

 	/**
 	 * Process InvocationTargetException to retrieve the actual target.
 	 * @param e
 	 *
 	 * @since 1.0.0
 	 */
 	protected final void processException(InvocationTargetException e) {
 		errorOccurred = true;
 		exception = e.getTargetException();
 	}

 	/**
 	 * Process EvaluationException to retrieve the actual target.
 	 * @param e
 	 *
 	 * @since 1.0.0
 	 */
 	protected final void processException(EvaluationException e) {
 		errorOccurred = true;
 		exception = e.getOriginalException();
 	}

 	/**
 	 * Special case for NoExpressionValueException caught.
 	 * @param e
 	 *
 	 * @since 1.0.0
 	 */
 	protected final void processException(NoExpressionValueException e) {
 		errorOccurred = true;
 		novalueMsg = e.getLocalizedMessage();
 		if (novalueMsg == null)
 			novalueMsg = "";	// It was null, so just default of empty string so we know it had occurred.
 	}

 	/**
 	 * Return whether there are any errors.
 	 *
 	 * @return <code>true</code> if no errors.
 	 *
 	 * @since 1.0.0
 	 */
 	public boolean noErrors() {
 		return !errorOccurred;
 	}

 	/**
 	 * Return the error code from ExpressionCommands if non-exception error occurred.
 	 * Return zero if no error.
 	 *
 	 * @return Zero if no error code to return, else error code from ExpressionCommands.
 	 *
 	 * @see org.eclipse.jem.internal.proxy.common.remote.ExpressionCommands#ExpressionNoExpressionValueException
 	 *
 	 * @since 1.0.0
 	 */
 	public int getErrorCode() {
 		if (novalueMsg != null)
 			return ExpressionCommands.ExpressionNoExpressionValueException;
 		else
 			return 0;
 	}

 	/**
 	 * Return the error message, should only be called if <code>getErrorCode()</code> returned non-zero.
 	 *
 	 * @return The error message if any. <code>null</code> otherwise.
 	 *
 	 * @since 1.0.0
 	 */
 	public String getErrorMsg() {
 		if (novalueMsg != null && novalueMsg.length() > 0)
 			return novalueMsg;
 		else
 			return null;
 	}

 	/**
 	 * Return the throwable if a Throwable was caught.
 	 *
 	 * @return The throwable, or <code>null</code> if not set.
 	 *
 	 * @since 1.0.0
 	 */
 	public Throwable getErrorThrowable() {
 		return exception;
 	}

 	/**
 	 * Close out things.
 	 *
 	 * @since 1.0.0
 	 */
 	public void close() {
 		exp.close();
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2004 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
	*******************************************************************************/
	/*
	* $RCSfile: ExpressionProcesserController.java,v $
	* $Revision: 1.5 $ $Date: 2005/02/15 22:57:54 $
	*/
	package org.eclipse.jem.internal.proxy.vm.remote;

	import java.io.DataInputStream;
	import java.io.IOException;
	import java.lang.reflect.InvocationTargetException;
	import java.util.Arrays;
	import java.util.List;

	import org.eclipse.jem.internal.proxy.common.*;
	import org.eclipse.jem.internal.proxy.common.CommandException;
	import org.eclipse.jem.internal.proxy.common.MapTypes;
	import org.eclipse.jem.internal.proxy.common.remote.Commands;
	import org.eclipse.jem.internal.proxy.common.remote.ExpressionCommands;
	import org.eclipse.jem.internal.proxy.initParser.EvaluationException;
	import org.eclipse.jem.internal.proxy.initParser.tree.ExpressionProcesser;
	import org.eclipse.jem.internal.proxy.initParser.tree.IInternalExpressionConstants;
	import org.eclipse.jem.internal.proxy.initParser.tree.IExpressionConstants.NoExpressionValueException;


	/**
	* This processes the commands for expression processing and sends them over
	* to the common expression processer.
	*
	* This will be instantiated on the start of an expression. And then
	* each expression request from the IDE will be sent into here. The
	* reason this guy doesn't hold onto the connection and process the
	* entire expression is because we need to return to the connection
	* handler to keep the connection live (there is timeouts and stuff
	* in there that we don't want to duplicate here).
	* <p>
	* If there are any expression processing errors (versus hard io errors) we
	* will save up the error but don't do any more processing other than to make
	* sure we read the complete subcommand. This is so that the inputstream is left
	* in a valid state without standed data.
	* <p>
	* The at the sync point (either get value or sync subcommand) we will send back
	* the error.
	*
	* @since 1.0.0
	*/
	public class ExpressionProcesserController {

	protected final RemoteVMServerThread server;
	protected final ConnectionHandler connHandler;
	protected final ExpressionProcesser exp;
	protected Commands.ValueObject workerValue = new Commands.ValueObject(); // A worker value object so we don't need to keep creating them and releasing them.
	private ClassLoader classLoader;

	/**
	* An error has occurred. At this point all subcommands will simply make sure they flush the input stream
	* correctly, but they do not process it.
	*
	* @since 1.0.0
	*/
	protected boolean errorOccurred = false;

	private String novalueMsg = null; // If NoExpressionValueException then this is the msg.
	private Throwable exception = null; // Was there another kind of exception that was caught.

	/**
	* Create with a default expression processer.
	* @param server
	*
	* @since 1.0.0
	*/
	public ExpressionProcesserController(RemoteVMServerThread server, ConnectionHandler connHandler) {
	this(server, connHandler, new ExpressionProcesser());
	}

	/**
	* Create from a subclass with a given expression processer.
	*
	* @param server
	* @param exp
	*
	* @since 1.0.0
	*/
	protected ExpressionProcesserController(RemoteVMServerThread server, ConnectionHandler connHandler, ExpressionProcesser exp) {
	this.server = server;
	this.connHandler = connHandler;
	this.exp = exp;
	}

	/**
	* Set the class loader to use for finding classes. If never set, or if <code>null</code>, then
	* <code>Class.forName</code> will be used.
	*
	* @param classLoader
	*
	* @since 1.0.0
	*/
	public void setClassLoader(ClassLoader classLoader) {
	this.classLoader = classLoader;
	}

	/*
	* Array of primitive type names. Used to look up primtive types in primitive types array.
	*
	* @since 1.0.0
	*/
	private static final List PRIMITIVE_NAMES = Arrays.asList(new String[] {"byte", "char", "short", "int", "long", "float", "double"});
	private static final Class[] PRIMITIVE_TYPES = new Class[] {Byte.TYPE, Character.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE, Float.TYPE, Double.TYPE};
	/**
	* Load the class given the name. If not found, return null.
	*
	* @param className
	* @return
	*
	* @since 1.0.0
	*/
	protected Class loadClass(String className) throws ClassNotFoundException {
	if (className == null)
	return null;
	else if (className.endsWith("[]")) {
	// We have an array request instead. This is trickier.
	return loadClass(MapTypes.getJNIFormatName(className));
	} else {
	int primIndex = PRIMITIVE_NAMES.indexOf(className);
	if (primIndex >= 0)
	return PRIMITIVE_TYPES[primIndex];
	else if (classLoader == null) {
	return Class.forName(className);
	} else {
	return classLoader.loadClass(className);
	}
	}
	}

	/**
	* Now process the input stream. If either throws occurs, this is a hard error and we must terminate
	* the entire connection. The input stream is in an unknown state.
	*
	* @param in The input stream to get the data for the current sub-command.
	*
	* @throws CommandException
	* @throws IOException
	* @since 1.0.0
	*/
	public void process(DataInputStream in) throws CommandException, IOException {
	// In the following subcommand processing, we always read the entire subcommand from the stream.
	// Then we check if an error has occurred in the past. If it has, we simply break. This is because
	// once an error occurred we don't want to continue wasting time evaluating, however we need to make
	// sure that the stream is read completely so that we don't have a corrupted input stream. That way
	// when all is done we can return the error and still have a valid connection socket.
	byte subcommand = in.readByte();
	try {
	switch (subcommand) {
	case IInternalExpressionConstants.PUSH_TO_PROXY_EXPRESSION :
	// Getting a proxy push. The value is sent as valueObject, so use that to read it in.
	Commands.readValue(in, workerValue);
	if (errorOccurred)
	break;
	Object value = connHandler.getInvokableObject(workerValue);
	if (value == null)
	exp.pushExpression(null, MethodHelper.NULL_TYPE);
	else if (workerValue.isPrimitive())
	exp.pushExpression(value, workerValue.getPrimitiveType());
	else
	exp.pushExpression(value, value.getClass());
	break;

	case IInternalExpressionConstants.CAST_EXPRESSION :
	// Get a cast request. The type is sent as valueObject.
	Commands.readValue(in, workerValue);
	if (errorOccurred)
	break;
	value = connHandler.getInvokableObject(workerValue);
	try {
	if (value instanceof String)
	value = loadClass((String) value);
	exp.pushCast((Class) value);
	} catch (NoExpressionValueException e) {
	processException(e);
	} catch (ClassNotFoundException e) {
	processException(e);
	}
	break;

	case IInternalExpressionConstants.INSTANCEOF_EXPRESSION :
	// Get a instanceof request. The type is sent as valueObject.
	Commands.readValue(in, workerValue);
	if (errorOccurred)
	break;
	value = connHandler.getInvokableObject(workerValue);
	try {
	if (value instanceof String)
	value = loadClass((String) value);
	exp.pushInstanceof((Class) value);
	} catch (ClassNotFoundException e) {
	processException(e);
	} catch (NoExpressionValueException e) {
	processException(e);
	}
	break;

	case IInternalExpressionConstants.INFIX_EXPRESSION :
	// Get an infix request. The operator and operand type are sent as bytes.
	byte infix_operator = in.readByte();
	byte infix_operandType = in.readByte();
	if (errorOccurred)
	break;
	try {
	exp.pushInfix(infix_operator, infix_operandType);
	} catch (NoExpressionValueException e1) {
	processException(e1);
	}
	break;

	case IInternalExpressionConstants.PREFIX_EXPRESSION :
	// Get a prefix request. The operator is sent as byte.
	byte prefix_operandType = in.readByte();
	if (errorOccurred)
	break;
	try {
	exp.pushPrefix(prefix_operandType);
	} catch (NoExpressionValueException e2) {
	processException(e2);
	}
	break;

	case IInternalExpressionConstants.TYPELITERAL_EXPRESSION :
	// Get a type literal request. The type string is sent as valueObject.
	Commands.readValue(in, workerValue);
	if (errorOccurred)
	break;
	value = connHandler.getInvokableObject(workerValue);
	try {
	value = loadClass((String) value);
	exp.pushExpression((Class) value, Class.class);
	} catch (ClassNotFoundException e) {
	processException(e);
	}
	break;

	case IInternalExpressionConstants.ARRAY_ACCESS_EXPRESSION :
	// Get an array access request. The index cound is sent as int.
	int arrayAccess_Indexcount = in.readInt();
	if (errorOccurred)
	break;
	try {
	exp.pushArrayAccess(arrayAccess_Indexcount);
	} catch (NoExpressionValueException e3) {
	processException(e3);
	}
	break;

	case IInternalExpressionConstants.ARRAY_CREATION_EXPRESSION :
	// Get an array creation request. The type is sent as valueObject, followed by int dimension count.
	Commands.readValue(in, workerValue);
	int arrayCreation_dimCount = in.readInt();
	if (errorOccurred)
	break;
	value = connHandler.getInvokableObject(workerValue);
	try {
	if (value instanceof String)
	value = loadClass((String) value);
	exp.pushArrayCreation((Class) value, arrayCreation_dimCount);
	} catch (ClassNotFoundException e) {
	processException(e);
	} catch (NoExpressionValueException e) {
	processException(e);
	}
	break;

	case IInternalExpressionConstants.ARRAY_INITIALIZER_EXPRESSION :
	// Get an array initializer request. The type is sent as valueObject, followed by int expression count.
	Commands.readValue(in, workerValue);
	int arrayInitializer_expressionCount = in.readInt();
	if (errorOccurred)
	break;
	value = connHandler.getInvokableObject(workerValue);
	try {
	if (value instanceof String)
	value = loadClass((String) value);
	exp.pushArrayInitializer((Class) value, arrayInitializer_expressionCount);
	} catch (ClassNotFoundException e) {
	processException(e);
	} catch (NoExpressionValueException e) {
	processException(e);
	}
	break;

	case IInternalExpressionConstants.CLASS_INSTANCE_CREATION_EXPRESSION :
	// Get a class instance creation request. The type is sent as valueObject, followed by int argument count.
	Commands.readValue(in, workerValue);
	int newInstance_argCount = in.readInt();
	if (errorOccurred)
	return;
	value = connHandler.getInvokableObject(workerValue);
	try {
	if (value instanceof String)
	value = loadClass((String) value);
	exp.pushClassInstanceCreation((Class) value, newInstance_argCount);
	} catch (ClassNotFoundException e) {
	processException(e);
	} catch (EvaluationException e) {
	processException(e);
	} catch (NoExpressionValueException e) {
	processException(e);
	} catch (InstantiationException e) {
	processException(e);
	} catch (IllegalAccessException e) {
	processException(e);
	} catch (InvocationTargetException e) {
	processException(e);
	} catch (LinkageError e) {
	processError(e);
	}
	break;

	case IInternalExpressionConstants.TYPERECEIVER_EXPRESSION :
	// Get a type receiver request. The type is sent as valueObject.
	Commands.readValue(in, workerValue);
	if (errorOccurred)
	break;
	value = connHandler.getInvokableObject(workerValue);
	try {
	if (value instanceof String)
	value = loadClass((String) value);
	exp.pushExpression(value, (Class) value);
	} catch (ClassNotFoundException e) {
	processException(e);
	}
	break;

	case IInternalExpressionConstants.FIELD_ACCESS_EXPRESSION :
	// Get a field access request. The field name sent as string, followed by hasReceiver as boolean.
	String fieldAccess_name = in.readUTF();
	boolean fieldAccess_receiver = in.readBoolean();
	if (errorOccurred)
	break;
	try {
	exp.pushFieldAccess(fieldAccess_name, fieldAccess_receiver);
	} catch (NoExpressionValueException e4) {
	processException(e4);
	} catch (NoSuchFieldException e4) {
	processException(e4);
	} catch (IllegalAccessException e4) {
	processException(e4);
	}
	break;

	case IInternalExpressionConstants.METHOD_EXPRESSION :
	// Get a method invocation request. The method name sent as string, followed by hasReceiver as boolean, and argCount as int.
	String method_name = in.readUTF();
	boolean method_receiver = in.readBoolean();
	int method_argCount = in.readInt();
	if (errorOccurred)
	break;
	try {
	exp.pushMethodInvocation(method_name, method_receiver, method_argCount);
	} catch (EvaluationException e5) {
	processException(e5);
	} catch (NoExpressionValueException e5) {
	processException(e5);
	} catch (IllegalAccessException e5) {
	processException(e5);
	} catch (InvocationTargetException e5) {
	processException(e5);
	}
	break;

	case IInternalExpressionConstants.CONDITIONAL_EXPRESSION :
	// Get a conditional expression request. The expression type (ie. condition/true/false) is sent as a byte
	byte conditional_type = in.readByte();
	if (errorOccurred)
	break;
	try {
	exp.pushConditional(conditional_type);
	} catch (NoExpressionValueException e6) {
	processException(e6);
	}
	break;
	}

	} catch (RuntimeException e) {
	processException(e);
	}

	workerValue.set(); // Clear it out so nothing being held onto.
	}


	/**
	* Pull the value. If an error occurred during this, then <code>null</code> is returned, and
	* caller should do normal error processing.
	*
	* @return r[0] is the value, r[1] is the type of the value. <code>null</code> if there was an error.
	*
	* @since 1.0.0
	*/
	public Object[] pullValue() {
	Object[] result = new Object[2];
	try {
	exp.pullValue(result);
	return result;
	} catch (NoExpressionValueException e) {
	processException(e);
	}
	return null;
	}

	/**
	* Process all other exceptions then the NoExpressionValueException, InvocationTargetException, and EvaluationException. This is
	* for exceptions that are not related to the input stream and shouldn't
	* cause the input stream to be closed.
	*
	* @param e
	*
	* @since 1.0.0
	*/
	protected final void processException(Exception e) {
	// Process all other exceptions.
	errorOccurred = true;
	exception = e;
	}

	/**
	* Process certain errors. Should not be called for general errors. Should be called for specific java.lang.Errors that
	* are not related to the input stream and shouldn't cause the input stream to be closed.
	*
	* @param e
	*
	* @since 1.0.2
	*/
	protected final void processError(Error e) {
	// Process specific errors
	errorOccurred = true;
	exception = e;
	}

	/**
	* Process InvocationTargetException to retrieve the actual target.
	* @param e
	*
	* @since 1.0.0
	*/
	protected final void processException(InvocationTargetException e) {
	errorOccurred = true;
	exception = e.getTargetException();
	}

	/**
	* Process EvaluationException to retrieve the actual target.
	* @param e
	*
	* @since 1.0.0
	*/
	protected final void processException(EvaluationException e) {
	errorOccurred = true;
	exception = e.getOriginalException();
	}

	/**
	* Special case for NoExpressionValueException caught.
	* @param e
	*
	* @since 1.0.0
	*/
	protected final void processException(NoExpressionValueException e) {
	errorOccurred = true;
	novalueMsg = e.getLocalizedMessage();
	if (novalueMsg == null)
	novalueMsg = ""; // It was null, so just default of empty string so we know it had occurred.
	}

	/**
	* Return whether there are any errors.
	*
	* @return <code>true</code> if no errors.
	*
	* @since 1.0.0
	*/
	public boolean noErrors() {
	return !errorOccurred;
	}

	/**
	* Return the error code from ExpressionCommands if non-exception error occurred.
	* Return zero if no error.
	*
	* @return Zero if no error code to return, else error code from ExpressionCommands.
	*
	* @see org.eclipse.jem.internal.proxy.common.remote.ExpressionCommands#ExpressionNoExpressionValueException
	*
	* @since 1.0.0
	*/
	public int getErrorCode() {
	if (novalueMsg != null)
	return ExpressionCommands.ExpressionNoExpressionValueException;
	else
	return 0;
	}

	/**
	* Return the error message, should only be called if <code>getErrorCode()</code> returned non-zero.
	*
	* @return The error message if any. <code>null</code> otherwise.
	*
	* @since 1.0.0
	*/
	public String getErrorMsg() {
	if (novalueMsg != null && novalueMsg.length() > 0)
	return novalueMsg;
	else
	return null;
	}

	/**
	* Return the throwable if a Throwable was caught.
	*
	* @return The throwable, or <code>null</code> if not set.
	*
	* @since 1.0.0
	*/
	public Throwable getErrorThrowable() {
	return exception;
	}

	/**
	* Close out things.
	*
	* @since 1.0.0
	*/
	public void close() {
	exp.close();
	}

	}