/*******************************************************************************
 * Copyright (c) 2009, 2010, 2011 Nokia 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:
 * Nokia - Initial API and implementation
 *******************************************************************************/
package org.eclipse.cdt.debug.edc.internal.services.dsf;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Executor;

import org.eclipse.cdt.core.IAddress;
import org.eclipse.cdt.core.dom.ast.IASTTypeId;
import org.eclipse.cdt.core.dom.ast.IBasicType;
import org.eclipse.cdt.debug.edc.MemoryUtils;
import org.eclipse.cdt.debug.edc.formatter.ITypeContentProvider;
import org.eclipse.cdt.debug.edc.formatter.IVariableValueConverter;
import org.eclipse.cdt.debug.edc.internal.EDCDebugger;
import org.eclipse.cdt.debug.edc.internal.EDCTrace;
import org.eclipse.cdt.debug.edc.internal.NumberFormatUtils;
import org.eclipse.cdt.debug.edc.internal.eval.ast.engine.ASTEvaluationEngine;
import org.eclipse.cdt.debug.edc.internal.eval.ast.engine.instructions.IArrayDimensionType;
import org.eclipse.cdt.debug.edc.internal.eval.ast.engine.instructions.InstructionSequence;
import org.eclipse.cdt.debug.edc.internal.eval.ast.engine.instructions.Interpreter;
import org.eclipse.cdt.debug.edc.internal.eval.ast.engine.instructions.OperandValue;
import org.eclipse.cdt.debug.edc.internal.formatter.FormatExtensionManager;
import org.eclipse.cdt.debug.edc.internal.services.dsf.Modules.ModuleDMC;
import org.eclipse.cdt.debug.edc.internal.symbols.IAggregate;
import org.eclipse.cdt.debug.edc.internal.symbols.IArrayType;
import org.eclipse.cdt.debug.edc.internal.symbols.ICPPBasicType;
import org.eclipse.cdt.debug.edc.internal.symbols.ICompositeType;
import org.eclipse.cdt.debug.edc.internal.symbols.IEnumeration;
import org.eclipse.cdt.debug.edc.internal.symbols.IField;
import org.eclipse.cdt.debug.edc.internal.symbols.IInheritance;
import org.eclipse.cdt.debug.edc.internal.symbols.IPointerType;
import org.eclipse.cdt.debug.edc.internal.symbols.IReferenceType;
import org.eclipse.cdt.debug.edc.internal.symbols.ISubroutineType;
import org.eclipse.cdt.debug.edc.launch.EDCLaunch;
import org.eclipse.cdt.debug.edc.services.AbstractEDCService;
import org.eclipse.cdt.debug.edc.services.DMContext;
import org.eclipse.cdt.debug.edc.services.IEDCDMContext;
import org.eclipse.cdt.debug.edc.services.IEDCExpression;
import org.eclipse.cdt.debug.edc.services.IEDCExpressions;
import org.eclipse.cdt.debug.edc.services.Stack.StackFrameDMC;
import org.eclipse.cdt.debug.edc.symbols.IDebugInfoProvider;
import org.eclipse.cdt.debug.edc.symbols.IEDCSymbolReader;
import org.eclipse.cdt.debug.edc.symbols.IEnumerator;
import org.eclipse.cdt.debug.edc.symbols.IInvalidVariableLocation;
import org.eclipse.cdt.debug.edc.symbols.IType;
import org.eclipse.cdt.debug.edc.symbols.IVariableLocation;
import org.eclipse.cdt.debug.edc.symbols.TypeEngine;
import org.eclipse.cdt.debug.edc.symbols.TypeUtils;
import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;
import org.eclipse.cdt.dsf.concurrent.ImmediateExecutor;
import org.eclipse.cdt.dsf.concurrent.Immutable;
import org.eclipse.cdt.dsf.concurrent.RequestMonitor;
import org.eclipse.cdt.dsf.datamodel.AbstractDMContext;
import org.eclipse.cdt.dsf.datamodel.AbstractDMEvent;
import org.eclipse.cdt.dsf.datamodel.DMContexts;
import org.eclipse.cdt.dsf.datamodel.IDMContext;
import org.eclipse.cdt.dsf.debug.service.IExpressions;
import org.eclipse.cdt.dsf.debug.service.IExpressions2;
import org.eclipse.cdt.dsf.debug.service.IFormattedValues;
import org.eclipse.cdt.dsf.debug.service.IModules.IModuleDMContext;
import org.eclipse.cdt.dsf.debug.service.IModules.ISymbolDMContext;
import org.eclipse.cdt.dsf.debug.service.IRegisters.IRegisterDMContext;
import org.eclipse.cdt.dsf.debug.service.IStack.IFrameDMContext;
import org.eclipse.cdt.dsf.service.DsfSession;
import org.eclipse.cdt.utils.Addr64;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;

public class Expressions extends AbstractEDCService implements IEDCExpressions {

	public abstract class BaseEDCExpressionDMC extends DMContext implements IEDCExpression {
		protected String expression;
		private InstructionSequence parsedExpression;
		private final ASTEvaluationEngine engine;
		private final StackFrameDMC frame;
		protected Number value;
		protected IStatus valueError;
		private IVariableLocation valueLocation;
		private IType valueType;
		private boolean hasChildren = false;
		private String valueString;

		public BaseEDCExpressionDMC(IDMContext parent, String expression, String name) {
			super(Expressions.this, new IDMContext[] { parent }, name, ((IEDCDMContext)parent).getID() + "." + name); //$NON-NLS-1$
			this.expression = expression;
			frame = DMContexts.getAncestorOfType(parent, StackFrameDMC.class);
			TypeEngine typeEngine;
			if (frame != null) {
				typeEngine = frame.getTypeEngine();
				engine = new ASTEvaluationEngine(getEDCServicesTracker(), frame, typeEngine);
			} else if (parent instanceof ModuleDMC) {
				IEDCSymbolReader edcSymbolReader = ((ModuleDMC)parent).getSymbolReader();
				if (edcSymbolReader instanceof EDCSymbolReader) {
					IDebugInfoProvider debugInfoProvider
					  = ((EDCSymbolReader)edcSymbolReader).getDebugInfoProvider();
					typeEngine = new TypeEngine(getTargetEnvironmentService(), debugInfoProvider);
					engine = new ASTEvaluationEngine(getEDCServicesTracker(), parent, typeEngine);
				} else {
					typeEngine = null;
					engine = null;
				}
			} else {
				typeEngine = null;
				engine = null;
			}
		}
		
		public BaseEDCExpressionDMC(IDMContext parent, String expression) {
			this(parent, expression, expression);
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.services.DMContext#toString()
		 */
		@Override
		public String toString() {
			return getExpression();
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.internal.services.dsf.IEDCExpression#getFrame()
		 */
		public IFrameDMContext getFrame() {
			return frame;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.internal.services.dsf.IEDCExpression#getExpression()
		 */
		public String getExpression() {
			return expression;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.internal.services.dsf.IEDCExpression#evaluateExpression()
		 */
		public synchronized void evaluateExpression() {
			if (value != null || valueError != null)
				return;
			
			String expression = getExpression();

			if (parsedExpression == null) {
				try {
					parsedExpression = engine.getCompiledExpression(expression);
				} catch (CoreException e) {
					value = null;
					valueError = e.getStatus();
					valueLocation = null;
					valueType = null;
					return;
				}
			}

			if (parsedExpression.getInstructions().length == 0) {
				value = null;
				valueError = new Status(IStatus.ERROR, EDCDebugger.PLUGIN_ID,
						EDCServicesMessages.Expressions_SyntaxError);
				valueLocation = null;
				valueType = null;
				return;
			}

			Interpreter interpreter;
			try {
				interpreter = engine.evaluateCompiledExpression(parsedExpression);
			} catch (CoreException e) {
				value = null;
				valueError = e.getStatus();
				valueLocation = null;
				valueType = null;
				return;
			}
			
			OperandValue variableValue = interpreter.getResult();
			if (variableValue == null) {
				value = null;
				valueError = null;
				valueLocation = null;
				valueType = null;
				return;
			}

			valueLocation = variableValue.getValueLocation();
			valueType = variableValue.getValueType();
			try {
				value = variableValue.getValue();
				valueString = variableValue.getStringValue();
			} catch (CoreException e1) {
				value = null;
				valueError = e1.getStatus();
				return;
			}

			// for a structured type or array, return the location and note
			// that it has children
			if (valueType instanceof IAggregate && valueLocation != null) {
				// TODO
				try {
					value = variableValue.getValueLocationAddress();
				} catch (CoreException e) {
					value = null;
					valueError = e.getStatus();
				}
				if (!(value instanceof IInvalidVariableLocation))
					hasChildren = true;
			}

			// if the location evaluates to NotLive, the types and values do
			// not matter
			if (valueLocation instanceof IInvalidVariableLocation) {
				value = null;
				valueError = new Status(IStatus.ERROR, EDCDebugger.PLUGIN_ID,
						((IInvalidVariableLocation) valueLocation).getMessage());
				valueLocation = null; //$NON-NLS-1$
				return;
			}

		}

		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.internal.services.dsf.IEDCExpression#getFormattedValue(org.eclipse.cdt.dsf.debug.service.IFormattedValues.FormattedValueDMContext)
		 */
		public FormattedValueDMData getFormattedValue(FormattedValueDMContext dmc) {
			if (EDCTrace.VARIABLE_VALUE_TRACE_ON) { EDCTrace.getTrace().traceEntry(null, EDCTrace.fixArg(dmc)); }
			evaluateExpression();
			String result = ""; //$NON-NLS-1$

			if (valueError != null) {
				result = valueError.getMessage();
			} else if (value != null) {
				result = value.toString();
				
				IType unqualifiedType = TypeUtils.getUnRefStrippedType(valueType);
				
				String temp = null;
				String formatID = dmc.getFormatID();
				
				// the non-natural formats have expected representations in other
				// parts of DSF, so be strict about what we return
				if (formatID.equals(IFormattedValues.HEX_FORMAT)) {
					temp = NumberFormatUtils.toHexString(value);
				} else if (formatID.equals(IFormattedValues.OCTAL_FORMAT)) {
					temp = NumberFormatUtils.toOctalString(value);
				} else if (formatID.equals(IFormattedValues.BINARY_FORMAT)) {
					temp = NumberFormatUtils.asBinary(value);
				} else if (formatID.equals(IFormattedValues.NATURAL_FORMAT)) {
					// convert non-integer types to original representation
					if (unqualifiedType instanceof ICPPBasicType) {
						ICPPBasicType basicType = (ICPPBasicType) unqualifiedType;
						switch (basicType.getBaseType()) {
						case ICPPBasicType.t_char:
							temp = NumberFormatUtils.toCharString(value, valueType);
							break;
						case ICPPBasicType.t_wchar_t:
							temp = NumberFormatUtils.toCharString(value, valueType);
							break;
						case ICPPBasicType.t_bool:
							temp = Boolean.toString(value.longValue() != 0);
							break;
						default:
							// account for other debug formats
							if (basicType.getName().equals("wchar_t")) { //$NON-NLS-1$
								temp = NumberFormatUtils.toCharString(value, valueType);
							}
							break;
						}
					} else if (unqualifiedType instanceof IAggregate || unqualifiedType instanceof IPointerType) {
						// show addresses for aggregates and pointers as hex in natural format
						temp = NumberFormatUtils.toHexString(value);
					} 
					
					// TODO: add type suffix if the value cannot fit in
					// the ordinary range of the base type.
					// E.g., for an unsigned int, 0xFFFFFFFF should usually be 0xFFFFFFFFU,
					// and for a long double, 1.E1000 should be 1.E1000L.
					/*
					// apply required integer and float suffixes
					IType unqualifiedType = TypeUtils.getStrippedType(valueType);
					if (unqualifiedType instanceof ICPPBasicType) {
						ICPPBasicType basicType = (ICPPBasicType) unqualifiedType;
						
						if (basicType.getBaseType() == ICPPBasicType.t_float) {
							//result += "F"; // no
						} else if (basicType.getBaseType() == ICPPBasicType.t_double) {
							if (basicType.isLong() AND actual value does not fit in a double)
								result += "L";
						} else if (basicType.getBaseType() == ICPPBasicType.t_int) {
							if (basicType.isUnsigned() AND actual value does not fit in a signed int)
								result += "U";
							if (basicType.isLongLong() AND actual value does not fit in a signed int)
								result += "LL";
							else if (basicType.isLong() AND actual value does not fit in a signed int)
								result += "L";
						}
					}
					 */
					
					// for an enumerator, return the name, if any
					if (unqualifiedType instanceof IEnumeration) {
						long enumeratorValue = value.longValue();

						IEnumerator enumerator = ((IEnumeration) unqualifiedType).getEnumeratorByValue(enumeratorValue);
						if (enumerator != null) {
							if (temp == null)
								temp = result;
							
							temp = enumerator.getName() + " [" + temp + "]"; //$NON-NLS-1$ //$NON-NLS-2$
						}
					}
				}
				if (temp != null)
					result = temp; 
				
				// otherwise, leave value as is
				
				
			}
			if (EDCTrace.VARIABLE_VALUE_TRACE_ON) { EDCTrace.getTrace().traceExit(null, EDCTrace.fixArg(result)); }
			return new FormattedValueDMData(result);
		}

		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.internal.services.dsf.IEDCExpression#getValueLocation()
		 */
		public IVariableLocation getValueLocation() {
			evaluateExpression();
			return getEvaluatedLocation();
		}

		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.services.IEDCExpression#getEvaluationError()
		 */
		public IStatus getEvaluationError() {
			return valueError;
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.internal.services.dsf.IEDCExpression#getEvaluatedValue()
		 */
		public Number getEvaluatedValue() {
			return value;
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.services.IEDCExpression#getEvaluatedValueString()
		 */
		public String getEvaluatedValueString() {
			if (valueError != null)
				return valueError.getMessage();
			
			if (valueString != null)
				return valueString;
			
			valueString = value != null ? value.toString() : ""; //$NON-NLS-1$
			return valueString;
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.services.IEDCExpression#setEvaluatedValueString(java.lang.String)
		 */
		public void setEvaluatedValueString(String string) {
			this.valueString = string;
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.internal.services.dsf.IEDCExpression#setEvaluatedValue(java.lang.Object)
		 */
		public void setEvaluatedValue(Number value) {
			this.value = value;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.internal.services.dsf.IEDCExpression#getEvaluatedLocation()
		 */
		public IVariableLocation getEvaluatedLocation() {
			return valueLocation;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.internal.services.dsf.IEDCExpression#getEvaluatedType()
		 */
		public IType getEvaluatedType() {
			return valueType;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.internal.services.dsf.IEDCExpression#getTypeName()
		 */
		public String getTypeName() {
			evaluateExpression();
			if (valueType == null)
				if (valueError != null)
					return ""; //$NON-NLS-1$
				else
					return ASTEvaluationEngine.UNKNOWN_TYPE;
			return engine.getTypeEngine().getTypeName(valueType);
		}

		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.internal.services.dsf.IEDCExpression#hasChildren()
		 */
		public boolean hasChildren() {
			return this.hasChildren;
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.internal.services.dsf.IEDCExpression#getService()
		 */
		public Expressions getExpressionsService() {
			return Expressions.this;
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.services.IEDCExpression#getExecutor()
		 */
		public Executor getExecutor() {
			return getSession().getExecutor();
		}
	
	}

	/** A basic expression.  */
	private class ExpressionDMC extends BaseEDCExpressionDMC {

		public ExpressionDMC(IDMContext parent, String expression) {
			super(parent, expression);
		}
		
		
		public ExpressionDMC(IDMContext parent, String expression, String name) {
			super(parent, expression, name);
		}
		
		/**
		 * There is no casting on a vanilla expression.
		 * @return <code>null</code>
		 */
		public CastInfo getCastInfo() {
			return null;
		}

		
	}

	/** A casted or array-displayed expression.  */
	private class CastedExpressionDMC extends BaseEDCExpressionDMC implements ICastedExpressionDMContext {

		private final CastInfo castInfo;
		/** if non-null, interpret result as this type rather than the raw expression's type */
		private IType castType = null;
		private IStatus castError;

		public CastedExpressionDMC(IEDCExpression exprDMC, String expression, String name, CastInfo castInfo) {
			super(exprDMC, name);
			this.castInfo = castInfo;
			
			String castType = castInfo.getTypeString();
			
			String castExpression = expression;
			
			// If changing type, assume it's reinterpret_cast<>. 
			// Once we support RTTI, this should be dynamic_cast<> when casting
			// class pointers to class pointers.
			if (castType != null) {
				if (castInfo.getArrayCount() > 0) {
					castType += "[]"; //$NON-NLS-1$
					// Force non-pointer expressions to be pointers.
					exprDMC.evaluateExpression();
					IType exprType = TypeUtils.getStrippedType(exprDMC.getEvaluatedType());
					if (exprType != null) {
						if (!(exprType instanceof IPointerType || exprType instanceof IArrayType)) {
							expression = "&" + expression; //$NON-NLS-1$
						}
					}
				}
				castExpression = "reinterpret_cast<" + castType +">(" + expression + ")"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
			} else if (castInfo.getArrayCount() > 0) {
				// For arrays, be sure the OperatorSubscript accepts the base type.
				// Force non-pointer expressions to be pointers.
				exprDMC.evaluateExpression();
				IType exprType = TypeUtils.getStrippedType(exprDMC.getEvaluatedType());
				if (exprType != null) {
					if (!(exprType instanceof IPointerType || exprType instanceof IArrayType)) {
						// cast to pointer if not already one (cast to array is not valid C/C++ but we support it)
						castExpression = "("  + exprDMC.getTypeName() + "[])&" + expression; //$NON-NLS-1$ //$NON-NLS-2$
					}
				}
			}
			this.expression = castExpression;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.internal.services.dsf.IEDCExpression#evaluateExpression()
		 */
		public void evaluateExpression() {
			if (castError != null) {
				return;
			}
			
			super.evaluateExpression();
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.cdt.debug.edc.internal.services.dsf.IEDCExpression#getEvaluatedType()
		 */
		public IType getEvaluatedType() {
			if (castType != null)
				return castType;
			return super.getEvaluatedType();
		}

		/* (non-Javadoc)
		 * @see org.eclipse.cdt.dsf.debug.service.IExpressions2.ICastedExpressionDMContext#getCastInfo()
		 */
		public CastInfo getCastInfo() {
			return castInfo;
		}
	}

	public class ExpressionData implements IExpressionDMData {

		private final IEDCExpression dmc;
		private String typeName = "";

		public ExpressionData(IEDCExpression dmc) {
			this.dmc = dmc;
			if (dmc != null)
				this.typeName = dmc.getTypeName();
		}

		public BasicType getBasicType() {
			BasicType basicType = BasicType.unknown;
			if (dmc == null)
				return basicType;
			
			IType type = dmc.getEvaluatedType();
			type = TypeUtils.getStrippedType(type);
			if (type instanceof IArrayType) {
				basicType = BasicType.array;
			}
			else if (type instanceof IBasicType) {
				basicType = BasicType.basic;
			}
			else if (type instanceof ICompositeType) {
				basicType = BasicType.composite;
			}
			else if (type instanceof IEnumeration) {
				basicType = BasicType.enumeration;
			}
			else if (type instanceof IPointerType) {
				basicType = BasicType.pointer;
			}
			else if (type instanceof ISubroutineType) {
				basicType = BasicType.function;
			}
			return basicType;
		}

		public String getEncoding() {
			return null;
		}

		public Map<String, Integer> getEnumerations() {
			return null;
		}

		public String getName() {
			if (dmc != null)
				return dmc.getName();
			else
				return ""; //$NON-NLS-1$
		}

		public IRegisterDMContext getRegister() {
			return null;
		}

		public String getTypeId() {
			return TYPEID_INTEGER;
		}

		public String getTypeName() {
			return typeName;
		}

	}

	protected static class InvalidContextExpressionDMC extends AbstractDMContext implements IExpressionDMContext {
		private final String expression;

		public InvalidContextExpressionDMC(String sessionId, String expr, IDMContext parent) {
			super(sessionId, new IDMContext[] { parent });
			expression = expr;
		}

		@Override
		public boolean equals(Object other) {
			return super.baseEquals(other) && expression == null ? ((InvalidContextExpressionDMC) other)
					.getExpression() == null : expression.equals(((InvalidContextExpressionDMC) other).getExpression());
		}

		@Override
		public int hashCode() {
			return expression == null ? super.baseHashCode() : super.baseHashCode() ^ expression.hashCode();
		}

		@Override
		public String toString() {
			return baseToString() + ".invalid_expr[" + expression + "]"; //$NON-NLS-1$ //$NON-NLS-2$
		}

		public String getExpression() {
			return expression;
		}
	}

	public class ExpressionDMAddress implements IExpressionDMLocation {

		private final IVariableLocation valueLocation;

		public ExpressionDMAddress(IExpressionDMContext exprContext) {
			if (exprContext instanceof IEDCExpression)
				valueLocation = ((IEDCExpression) exprContext).getValueLocation();
			else
				valueLocation = null;
		}

		public IAddress getAddress() {
			if (valueLocation != null) {
				IAddress address = valueLocation.getAddress();
				if (address != null)
					return address;
			}
			return new Addr64(BigInteger.ZERO);
		}

		public int getSize() {
			return 4;
		}

		public String getLocation() {
			if (valueLocation instanceof IInvalidVariableLocation) {
				return ((IInvalidVariableLocation)valueLocation).getMessage();
			}
			if (valueLocation == null)
				return ""; //$NON-NLS-1$
			return valueLocation.getLocationName();
		}

	}

	public Expressions(DsfSession session) {
		super(session, new String[] { IExpressions.class.getName(), Expressions.class.getName(), IExpressions2.class.getName() });
	}
	
	public boolean canWriteExpression(IEDCExpression expressionDMC) {
		EDCLaunch launch = EDCLaunch.getLaunchForSession(getSession().getId());
		if (launch.isSnapshotLaunch())
			return false;
		IVariableValueConverter converter = getCustomValueConverter(expressionDMC);
		if (converter != null)
			return converter.canEditValue();
		
		return !isComposite(expressionDMC);
	}

	public void canWriteExpression(IExpressionDMContext exprContext, DataRequestMonitor<Boolean> rm) {
		IEDCExpression expressionDMC = (IEDCExpression) exprContext;
		rm.setData(canWriteExpression(expressionDMC));
		rm.done();
	}

	private boolean isComposite(IEDCExpression expressionDMC) {
		IType exprType = TypeUtils.getStrippedType(expressionDMC.getEvaluatedType());
		return exprType instanceof ICompositeType;
	}

	public IExpressionDMContext createExpression(IDMContext context, String expression) {
		StackFrameDMC frameDmc = DMContexts.getAncestorOfType(context, StackFrameDMC.class);

		if (frameDmc != null) {
			return new ExpressionDMC(frameDmc, expression);
		} else if (context instanceof IModuleDMContext) {
			return new ExpressionDMC(context, expression); 
		}
		return new InvalidContextExpressionDMC(getSession().getId(), expression, context);
	}
	
	class CastInfoCachedData  {

		private CastInfo info;

		private IType type;
		private IStatus error;
		private StackFrameDMC frameDmc;

		public CastInfoCachedData(ExpressionDMC exprDMC, CastInfo info) {
			this.info = info;
			this.frameDmc = DMContexts.getAncestorOfType(exprDMC, StackFrameDMC.class);
		}
		
		public String getTypeString() {
			return info.getTypeString();
		}
		
		public int getArrayStartIndex() {
			return info.getArrayStartIndex();
		}
		
		public int getArrayCount() {
			return info.getArrayCount();
		}
		
		/**
		 * Get the compiled type
		 * @return the type
		 */
		public IType getType() {
			if (info.getTypeString() == null)
				return null;
			
			if (type == null && error == null) {
				if (frameDmc != null) {
					ASTEvaluationEngine engine = new ASTEvaluationEngine(getEDCServicesTracker(), frameDmc, frameDmc.getTypeEngine());
					try {
						IASTTypeId typeId = engine.getCompiledType(info.getTypeString());
						type = engine.getTypeEngine().getTypeForTypeId(typeId);
					} catch (CoreException e) {
						error = e.getStatus();
					}
				} else {
					error = EDCDebugger.dsfRequestFailedStatus(EDCServicesMessages.Expressions_CannotCastOutsideFrame, null); 
				}
			}
			return type;
		}
		
		/**
		 * @return the error
		 */
		public IStatus getError() {
			if (type == null && error == null) {
				getType();
			}
			return error;
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.cdt.dsf.debug.service.IExpressions2#createCastedExpression(org.eclipse.cdt.dsf.datamodel.IDMContext, java.lang.String, org.eclipse.cdt.dsf.debug.service.IExpressions2.ICastedExpressionDMContext)
	 */
	public ICastedExpressionDMContext createCastedExpression(IExpressionDMContext exprDMC,
			CastInfo castInfo) {
		
		// then apply the casting stuff
		if (exprDMC instanceof IEDCExpression) {
			CastedExpressionDMC castedDMC = new CastedExpressionDMC((IEDCExpression) exprDMC, 
					exprDMC.getExpression(), ((IEDCExpression) exprDMC).getName(), castInfo);
			return castedDMC;
		} else {
			assert false;
			return null;
		}
	}

	/*
	public void createCastedExpression(IDMContext context, String expression, 
			ICastedExpressionDMContext castDMC, IArrayCastedExpressionDMContext arrayCastDMC,
			DataRequestMonitor<IExpressionDMContext> rm) {
		
		// create an ordinary expression...
		IExpressionDMContext exprDMC = createExpression(context, expression);
		
		// then apply the casting stuff
		if (exprDMC instanceof ExpressionDMC 
				&& (castDMC == null || castDMC instanceof CastedExpressionDMContext)
				&& (arrayCastDMC == null || arrayCastDMC instanceof ArrayCastedExpressionDMContext)) {
			ExpressionDMC expressionDMC = ((ExpressionDMC) exprDMC);
			if (castDMC != null)
				expressionDMC.setCastToType((CastedExpressionDMContext) castDMC);
			if (arrayCastDMC != null)
				expressionDMC.setArrayCast((ArrayCastedExpressionDMContext) arrayCastDMC);
			rm.setData(expressionDMC);
			rm.done();
		} else {
			assert false;
			rm.setStatus(EDCDebugger.dsfRequestFailedStatus("unexpected cast information", null));
			rm.done();
		}
	}
	*/
	
	public void getBaseExpressions(IExpressionDMContext exprContext, DataRequestMonitor<IExpressionDMContext[]> rm) {
		rm.setData(new IEDCExpression[0]);
		rm.done();
	}

	public void getExpressionAddressData(final IExpressionDMContext exprContext, final DataRequestMonitor<IExpressionDMAddress> rm) {
		asyncExec(new Runnable() {
			public void run() {
				if (exprContext instanceof IEDCExpression)
					rm.setData(new ExpressionDMAddress(exprContext));
				else
					rm.setData(new ExpressionDMAddress(null));
				rm.done();
			}
		}, rm);
	}

	public void getExpressionData(final IExpressionDMContext exprContext, final DataRequestMonitor<IExpressionDMData> rm) {
		asyncExec(new Runnable() {
			public void run() {
				if (exprContext instanceof IEDCExpression)
					rm.setData(new ExpressionData((IEDCExpression) exprContext));
				else
					rm.setData(new ExpressionData(null));
				rm.done();
			}
		}, rm);
	}

	public void getSubExpressionCount(final IExpressionDMContext exprContext, final DataRequestMonitor<Integer> rm) {
		asyncExec(new Runnable() {
			public void run() {
				// handle array casts
				CastInfo cast = null;
				if (exprContext instanceof IEDCExpression && (cast = ((IEDCExpression) exprContext).getCastInfo()) != null) { 
					if (cast.getArrayCount() > 0) {
						if (((IEDCExpression)exprContext).getEvaluationError() != null) {
							rm.setData(0);
							rm.done();
							return;
						}
						rm.setData(cast.getArrayCount());
						rm.done();
						return;
					}
				}

				if (!(exprContext instanceof IEDCExpression)) {
					rm.setData(0);
					rm.done();
					return;
				}

				IEDCExpression expr = (IEDCExpression) exprContext;

				// if expression has no evaluated value, then it has not yet been evaluated
				if (expr.getEvaluatedValue() == null && expr.getEvaluatedValueString() != null) {
					expr.evaluateExpression();
				}

				IType exprType = TypeUtils.getStrippedType(expr.getEvaluatedType());
				
				// to expand it, it must either be a pointer, a reference to an aggregate,
				// or an aggregate
				boolean pointerType = exprType instanceof IPointerType;
				boolean referenceType = exprType instanceof IReferenceType;
				IType pointedTo = null;
				if (referenceType)
					pointedTo = TypeUtils.getStrippedType(((IReferenceType) exprType).getType());
				
				if (!(exprType instanceof IAggregate) && !pointerType &&
					!(referenceType && (pointedTo instanceof IAggregate || pointedTo instanceof IPointerType))) {
					rm.setData(0);
					rm.done();
					return;
				}
				
				ITypeContentProvider customProvider = 
					FormatExtensionManager.instance().getTypeContentProvider(exprType);
				if (customProvider != null) {
					try {
						rm.setData(customProvider.getChildCount(expr));
						rm.done();
						return;
					} catch (Throwable e) {
					}
				}

				// TODO: maybe cache these subexpressions; they are just requested again in #getSubExpressions()
				getSubExpressions(exprContext, new DataRequestMonitor<IExpressions.IExpressionDMContext[]>(
						getExecutor(), rm) {
					/* (non-Javadoc)
					 * @see org.eclipse.cdt.dsf.concurrent.RequestMonitor#handleSuccess()
					 */
					@Override
					protected void handleSuccess() {
						rm.setData(getData().length);
						rm.done();
					}
				});
			}
		}, rm);
	}

	public void getSubExpressions(final IExpressionDMContext exprContext, final DataRequestMonitor<IExpressionDMContext[]> rm) {
		asyncExec(new Runnable() {
			public void run() {
				if (!(exprContext instanceof IEDCExpression) || ((IEDCExpression) exprContext).getFrame() == null) {
					rm.setData(new IEDCExpression[0]);
					rm.done();
					return;
				}

				IEDCExpression expr = (IEDCExpression) exprContext;

				// if expression has no evaluated value, then it has not yet been evaluated
				if (expr.getEvaluatedValue() == null && expr.getEvaluatedValueString() != null) {
					expr.evaluateExpression();
				}

				StackFrameDMC frame = (StackFrameDMC) expr.getFrame();
				IType exprType = TypeUtils.getStrippedType(expr.getEvaluatedType());

				// if casted to an array, convert thusly
		    	CastInfo castInfo = expr.getCastInfo();
		    	if (castInfo != null && castInfo.getArrayCount() > 0) {
		    		try {
		    			exprType = frame.getTypeEngine().convertToArrayType(exprType, castInfo.getArrayCount());
		    		} catch (CoreException e) {
		    			rm.setStatus(e.getStatus());
		    			rm.done();
		    			return;
		    		}
		    	}
		    	
				
				// to expand it, it must either be a pointer, a reference to an aggregate,
				// or an aggregate
				boolean pointerType = exprType instanceof IPointerType;
				boolean referenceType = exprType instanceof IReferenceType;
				IType pointedTo = null;
				if (referenceType) {
					pointedTo = TypeUtils.getStrippedType(((IReferenceType) exprType).getType());
					exprType = pointedTo;
				}
				
				if (!(exprType instanceof IAggregate) && !pointerType &&
					!(referenceType && (pointedTo instanceof IAggregate || pointedTo instanceof IPointerType))) {
					rm.setData(new IEDCExpression[0]);
					rm.done();
					return;
				}
				
				ITypeContentProvider customProvider = 
					FormatExtensionManager.instance().getTypeContentProvider(exprType);
				if (customProvider != null) {
					getSubExpressions(expr, frame, exprType, customProvider, rm);
				}
				else
					getSubExpressions(expr, rm);
			}
		}, rm);
	}

	public void getSubExpressions(final IExpressionDMContext exprContext, final int startIndex_, final int length_,
			final DataRequestMonitor<IExpressionDMContext[]> rm) {
		asyncExec(new Runnable() {
			public void run() {
				getSubExpressions(exprContext, new DataRequestMonitor<IExpressionDMContext[]>(getExecutor(), rm) {
					@Override
					protected void handleSuccess() {
						IExpressionDMContext[] allExprs = getData();
						if (startIndex_ == 0 && length_ >= allExprs.length) {
							rm.setData(allExprs);
							rm.done();
						} else {
							int startIndex = startIndex_, length = length_;
							if (startIndex > allExprs.length) {
								startIndex = allExprs.length;
								length = 0;
							} else if (startIndex + length > allExprs.length) {
								length = allExprs.length - startIndex;
								if (length < 0)
									length = 0;
							}
								
							IExpressionDMContext[] result = new IExpressionDMContext[length];
							System.arraycopy(allExprs, startIndex, result, 0, length);
							rm.setData(result);
							rm.done();
						}
					}
				});
			}
		}, rm);
	}

	private void getSubExpressions(final IEDCExpression expr, final StackFrameDMC frame, 
			final IType exprType, final ITypeContentProvider customProvider,
			final DataRequestMonitor<IExpressionDMContext[]> rm) {

		List<IExpressionDMContext> children = new ArrayList<IExpressionDMContext>();
		Iterator<IExpressionDMContext> childIterator;
		try {
			childIterator = customProvider.getChildIterator(expr);
			while (childIterator.hasNext() && !rm.isCanceled()) {
				children.add(childIterator.next());
			}
			rm.setData(children.toArray(new IExpressionDMContext[children.size()]));
			rm.done();
		} catch (CoreException e) {
			// Checked exception. But we don't want to pass the error up as it
			// would make the variable (say, a structure) not expandable on UI. 
			// Just resort to the normal formatting.  
			getSubExpressions(expr, rm);
		} catch (Throwable e) {
			// unexpected error. log it.
			EDCDebugger.getMessageLogger().logError(
					EDCServicesMessages.Expressions_ErrorInVariableFormatter + customProvider.getClass().getName(), e);
			
			// default to normal formatting
			getSubExpressions(expr, rm);
		}
	}

	private void getSubExpressions(final IEDCExpression expr, 
			final DataRequestMonitor<IExpressionDMContext[]> rm) {
		rm.setData(getLogicalSubExpressions(expr));
		rm.done();
	}
	
	/**
	 * Get the logical subexpressions for the given expression context.  We want
	 * to skip unnecessary nodes, e.g., a pointer to a composite, and directly
	 * show the object contents.
	 * @param expr the expression from which to start
	 * @return array of children
	 */
	public IEDCExpression[] getLogicalSubExpressions(IEDCExpression expr) {

		IType exprType = TypeUtils.getUnRefStrippedType(expr.getEvaluatedType());
		
		// cast to array?
		CastInfo castInfo = expr.getCastInfo();
		if (castInfo != null && castInfo.getArrayCount() > 0) {
			
			String exprName = expr.getExpression();
			
			// in case of casts, need to resolve that before dereferencing, so be safe
			if (exprName.contains("(")) //$NON-NLS-1$
				exprName = '(' + exprName + ')';

			long lowerBound = castInfo.getArrayStartIndex();
			long count = castInfo.getArrayCount();
			
			List<IEDCExpression> arrayChildren = new ArrayList<IEDCExpression>();
			for (int i = 0; i < count; i++) {
				String arrayElement = "[" + (i + lowerBound) + "]"; //$NON-NLS-1$ //$NON-NLS-2$
				IEDCExpression newExpr = new ExpressionDMC(expr.getFrame(), (exprName + arrayElement),
						expr.getName() + arrayElement);
				IEDCExpression exprChild = newExpr; //$NON-NLS-1$ //$NON-NLS-2$
				if (exprChild != null) {
					arrayChildren.add(exprChild);
				}
			}

			return arrayChildren.toArray(new IEDCExpression[arrayChildren.size()]);
		} 
		
		if (exprType instanceof IPointerType) {
			// automatically dereference a pointer
			String exprName = expr.getExpression();
			IType typePointedTo = TypeUtils.getStrippedType(exprType.getType());

			// Try to resolve opaque pointer. 
			// Note this may take some time depending on symbol file size. 
			// ........05/19/11
			//
			if (TypeUtils.isOpaqueType(typePointedTo)) {
				final Symbols symService = getService(Symbols.class);
				assert symService != null;
				
				final ISymbolDMContext symCtx = DMContexts.getAncestorOfType(expr, ISymbolDMContext.class);
				if (symCtx != null) {
					final ICompositeType[] resolved = {null};
					final IType original = typePointedTo;
					Job j = new Job("Resolving opaque type" + original.getName()) {
						@Override
						protected IStatus run(IProgressMonitor monitor) {
							monitor.beginTask("Resolving opaque type: " + original.getName(), IProgressMonitor.UNKNOWN);
							resolved[0] = symService.resolveOpaqueType(symCtx, (ICompositeType)original);
							monitor.done();
							return Status.OK_STATUS;
						}};
						
					j.schedule();
					try {
						j.join();
					} catch (InterruptedException e) {
						// ignore
					}
					
					if (resolved[0] != null) {
						typePointedTo = resolved[0];
						
						// Make the pointer type points to the resolved type
						// so that we won't need to resolve the opaque type again
						// and again.
						exprType.setType(resolved[0]);
					}
				}
			}
			
			// If expression name already starts with "&" (e.g. "&struct"), indirect it first
			boolean indirected = false;
			
			IEDCExpression exprChild;
			
			if (exprName.startsWith("&")) { //$NON-NLS-1$
				exprName = exprName.substring(1);
				IEDCExpression newExpr = new ExpressionDMC(expr.getFrame(), exprName);
				exprChild = newExpr;
				indirected = true;
			} 
			else {
				// avoid dereferencing void pointer
				if (typePointedTo instanceof ICPPBasicType 
						&& ((ICPPBasicType) typePointedTo).getBaseType() == ICPPBasicType.t_void) {
					return new IEDCExpression[0];
				}
				
				// do not dereference null either
				if (expr.getEvaluatedValue() != null && expr.getEvaluatedValue().intValue() == 0)
					return new IEDCExpression[0];
				IEDCExpression newExpr = new ExpressionDMC(expr.getFrame(), ("*" + exprName), "*" + expr.getName()); //$NON-NLS-1$ //$NON-NLS-2$
					
				// a pointer type has one child
				exprChild = newExpr; //$NON-NLS-1$
			}
			
			return doGetLogicalSubExpressions(exprChild, typePointedTo, indirected);
		} 
		else if (exprType instanceof IReferenceType) {
			// and bypass a reference
			
			IType typePointedTo = TypeUtils.getStrippedType(exprType.getType());
			return doGetLogicalSubExpressions(expr, typePointedTo, false);
		}else {
			// normal aggregate, just do it
			return doGetLogicalSubExpressions(expr, exprType, false);
		}
		
	}

	/**
	 * Get the logical subexpressions for the given expression context and string 
	 * @param expr the expression from which to start
	 * @param exprType the type in which to consider the expression
	 * @param indirected if true, the expression was already indirected, as opposed to what the expression says
	 * @return
	 */
	private IEDCExpression[] doGetLogicalSubExpressions(IEDCExpression expr, IType exprType, boolean indirected) {
		ArrayList<IEDCExpression> exprList = new ArrayList<IEDCExpression>();
		IEDCExpression exprChild;

		String expression = expr.getExpression();
		
		// in case of casts, need to resolve that before dereferencing, so be safe
		if (expression.contains("(")) //$NON-NLS-1$
			expression = '(' + expression + ')';

		/*
		// cast to array?
		CastInfo castInfo = expr.getCastInfo();
		if (castInfo != null && castInfo.getArrayCount() > 0) {
			long lowerBound = castInfo.getArrayStartIndex();
			long count = castInfo.getArrayCount();
			for (int i = 0; i < count; i++) {
				exprChild = createDerivedExpression(expr, exprName + "[" + (i + lowerBound) + "]"); //$NON-NLS-1$ //$NON-NLS-2$
				if (exprChild != null) {
					exprList.add(exprChild);
				}
			}
		
		} 
		else*/ if (exprType instanceof ICompositeType) {
			// an artifact of following a pointer to a structure is that the
			// name starts with '*'
			if (expression.startsWith("*")) { //$NON-NLS-1$
				if (expression.startsWith("**"))
					expression = "(" + expression.substring(1) + ")->"; //$NON-NLS-1$
				else
					expression = expression.substring(1) + "->"; //$NON-NLS-1$
			} else {
				expression = expression + '.'; //$NON-NLS-1$
			}

			// for each field, evaluate an expression, then shorten the name
			ICompositeType compositeType = (ICompositeType) exprType;

			for (IField field : compositeType.getFields()) {
				String fieldName = field.getName();
				if (fieldName.length() == 0) {
					// This makes an invalid expression
					// The debug info provider should have filtered out or renamed such fields
					assert false;
					continue;
				}
				exprChild = new ExpressionDMC(expr.getFrame(), expression + fieldName, fieldName);
				if (exprChild != null) {
					exprList.add(exprChild);
				}
			}

			for (IInheritance inherited : compositeType.getInheritances()) {
				String inheritedName = inherited.getName();
				if (inheritedName.length() == 0) {
					// This makes an invalid expression
					// The debug info provider should have filtered out or renamed such fields
					assert false;	// couldn't this be the case for an anonymous member, like a union?
				} else if (!inheritedName.contains("<")) {
					exprChild = new ExpressionDMC(expr.getFrame(), expression + inheritedName, inheritedName);
					if (exprChild != null) {
						exprList.add(exprChild);
					}
				} else {
					IType inheritedType = inherited.getType(); 
					if (inheritedType instanceof ICompositeType) {
						for (IField field : ((ICompositeType)inheritedType).getFields()) {
							String fieldName = field.getName();
							if (fieldName.length() == 0) {
								// This makes an invalid expression
								// The debug info provider should have filtered out or renamed such fields
								assert false;
								continue;
							}
							exprChild = new ExpressionDMC(expr.getFrame(), expression + fieldName, fieldName);
							if (exprChild != null) {
								exprList.add(exprChild);
							}
						}
					}
				}
			}
			
		} 
		else if (exprType instanceof IArrayType) {
			IArrayType arrayType = (IArrayType) exprType;

			if (arrayType.getBoundsCount() > 0) {
				long lowerBound = expr.getCastInfo() != null && expr.getCastInfo().getArrayCount() > 0 
					? expr.getCastInfo().getArrayStartIndex() : 0;
				long upperBound = arrayType.getBound(0).getBoundCount();
				if (upperBound == 0)
					upperBound = 1;
				for (int i = 0; i < upperBound; i++) {
					String arrayElementName = "[" + (i + lowerBound) + "]"; //$NON-NLS-1$ //$NON-NLS-2$
					IEDCExpression newExpr = new ExpressionDMC(expr.getFrame(), expression + arrayElementName,
							expr.getName() + arrayElementName); 
					exprChild = newExpr;
					if (exprChild != null) {
						exprList.add(exprChild);
					}
				}
			}
		} 
		else if (exprType instanceof IArrayDimensionType) {
			IArrayDimensionType arrayDimensionType = (IArrayDimensionType) exprType;
			IArrayType arrayType = arrayDimensionType.getArrayType();

			if (arrayType.getBoundsCount() > arrayDimensionType.getDimensionCount()) {
				long lowerBound = expr.getCastInfo() != null && expr.getCastInfo().getArrayCount() > 0 
				? expr.getCastInfo().getArrayStartIndex() : 0;
				long upperBound = arrayType.getBound(arrayDimensionType.getDimensionCount()).getBoundCount();
				for (int i = 0; i < upperBound; i++) {
					String arrayElement = "[" + (i + lowerBound) + "]"; //$NON-NLS-1$ //$NON-NLS-2$
					IEDCExpression newExpr = new ExpressionDMC(expr.getFrame(), expression + arrayElement,
							expr.getName() + arrayElement); 
					exprChild = newExpr;
					if (exprChild != null) {
						exprList.add(exprChild);
					}
				}
			}
		} 
		else {
			// nothing interesting
			exprList.add(expr);
		}

		return exprList.toArray(new IEDCExpression[exprList.size()]);
	}

	@Immutable
    private static class ExpressionChangedDMEvent extends AbstractDMEvent<IExpressionDMContext> implements IExpressionChangedDMEvent {
        ExpressionChangedDMEvent(IExpressionDMContext expression) {
            super(expression);
        }
    }

	public void writeExpression(final IExpressionDMContext exprContext, final String expressionValue, final String formatId, final RequestMonitor rm) {

		asyncExec(new Runnable() {
			public void run() {
				IEDCExpression expressionDMC = (IEDCExpression) exprContext;
				if (isComposite(expressionDMC)) {
					rm.setStatus(EDCDebugger.dsfRequestFailedStatus(EDCServicesMessages.Expressions_CannotModifyCompositeValue, null));
					rm.done();
					return;
				}

				IType exprType = TypeUtils.getStrippedType(expressionDMC.getEvaluatedType());

				// first try to get value by format as BigInteger
				Number number = NumberFormatUtils.parseIntegerByFormat(expressionValue, formatId);
		        if (number == null) {
		       		IEDCExpression temp = (IEDCExpression) createExpression(expressionDMC.getFrame(), expressionValue);
		       		temp.evaluateExpression();
					number = temp.getEvaluatedValue();

		       		if (number == null) {
		       			rm.setStatus(EDCDebugger.dsfRequestFailedStatus(EDCServicesMessages.Expressions_CannotParseExpression, null));
		       			rm.done();
		       			return;
		       		}
		        }
		        
		        BigInteger value = null;
				try {
					value = MemoryUtils.convertValueToMemory(exprType, number);
				} catch (CoreException e) {
		   			rm.setStatus(e.getStatus());
		   			rm.done();
		   			return;
				}
		        
		        IVariableLocation variableLocation = expressionDMC.getValueLocation();
		        if (variableLocation == null) {
		        	rm.setStatus(EDCDebugger.dsfRequestFailedStatus(EDCServicesMessages.Expressions_ExpressionNoLocation, null));
		   			rm.done();
		   			return;
		        }
		        	
		    	try {
		    		variableLocation.writeValue(exprType.getByteSize(), value);
		    		getSession().dispatchEvent(new ExpressionChangedDMEvent(exprContext), getProperties());
				} catch (CoreException e) {
					rm.setStatus(e.getStatus());
				}
		        
				rm.done();
			}
		}, rm);

	}

	public void getAvailableFormats(IFormattedDataDMContext formattedDataContext, DataRequestMonitor<String[]> rm) {
		rm.setData(new String[] { IFormattedValues.NATURAL_FORMAT, IFormattedValues.DECIMAL_FORMAT, 
				IFormattedValues.HEX_FORMAT, IFormattedValues.OCTAL_FORMAT, IFormattedValues.BINARY_FORMAT });
		rm.done();
	}

	public void getFormattedExpressionValue(final FormattedValueDMContext formattedDataContext,
			final DataRequestMonitor<FormattedValueDMData> rm) {
		asyncExec(new Runnable() {
			public void run() {
				try {
					rm.setData(getFormattedExpressionValue(formattedDataContext));
					rm.done();
				} catch (CoreException ce) {
					rm.setStatus(ce.getStatus());
					rm.done();
					return;
				}
			}
		}, rm);
	}

	public String getExpressionValueString(IExpressionDMContext expression, String format) throws CoreException {
		FormattedValueDMContext formattedDataContext = getFormattedValueContext(expression, format);
		FormattedValueDMData formattedValue = getFormattedExpressionValue(formattedDataContext);
		
		return formattedValue != null ? formattedValue.getFormattedValue() : "";
	}

	public FormattedValueDMData getFormattedExpressionValue(FormattedValueDMContext formattedDataContext) throws CoreException {
		IDMContext idmContext = formattedDataContext.getParents()[0];
		FormattedValueDMData formattedValue = null;
		IEDCExpression exprDMC = null;

		if (idmContext instanceof IEDCExpression) {
			exprDMC = (IEDCExpression) formattedDataContext.getParents()[0];

			exprDMC.evaluateExpression();
			
			if (exprDMC != null && exprDMC.getEvaluationError() != null) {
				throw new CoreException(exprDMC.getEvaluationError());
			}
			
			formattedValue = exprDMC.getFormattedValue(formattedDataContext); // must call this to get type
			
			if (formattedDataContext.getFormatID().equals(IFormattedValues.NATURAL_FORMAT))
			{
				IVariableValueConverter customConverter = getCustomValueConverter(exprDMC);
				if (customConverter != null) {
					FormattedValueDMData customFormattedValue = null;
					try {
						customFormattedValue = new FormattedValueDMData(customConverter.getValue(exprDMC));
						formattedValue = customFormattedValue;
					}
					catch (CoreException e) {
						// Checked exception like failure in reading memory.  just re-throw
						// it so it shows up in the variables view.
						throw e;
					} catch (Throwable t) {
						// Other unexpected errors, usually bug in the formatter. Log it 
						// so that user will be able to see and report the bug. 
						// Meanwhile default to normal formatting so that user won't see 
						// such error in Variable UI.
						EDCDebugger.getMessageLogger().logError(
								EDCServicesMessages.Expressions_ErrorInVariableFormatter + customConverter.getClass().getName(), t);
					}
				}
			}
		} else
			formattedValue = new FormattedValueDMData(""); //$NON-NLS-1$
		
		return formattedValue;
	}

	private IVariableValueConverter getCustomValueConverter(IEDCExpression exprDMC) {
		IType exprType = TypeUtils.getUnRefStrippedType(exprDMC.getEvaluatedType());
		return FormatExtensionManager.instance().getVariableValueConverter(exprType);
	}

	public FormattedValueDMContext getFormattedValueContext(IFormattedDataDMContext formattedDataContext,
			String formatId) {
		return new FormattedValueDMContext(this, formattedDataContext, formatId);
	}

	public void getModelData(IDMContext context, DataRequestMonitor<?> rm) {
	}

	public String getExpressionValue(IExpressionDMContext expression)
	{
		final StringBuffer holder = new StringBuffer();
		FormattedValueDMContext formattedValueContext = getFormattedValueContext(expression, IFormattedValues.NATURAL_FORMAT);					
		getFormattedExpressionValue(formattedValueContext, new DataRequestMonitor<FormattedValueDMData>(ImmediateExecutor.getInstance(), null) {
			@Override
			protected void handleSuccess() {
				holder.append(this.getData().getFormattedValue());
			}

			@Override
			protected void handleFailure() {
				// RequestMonitor would by default log any error if it's not explicitly 
				// handled. But we don't want to log those expected errors (checked exceptions)
				// in such case as creating snapshot. Hence this dummy handler...02/17/10
				
				// DO nothing.
			}
			
			
		});
		return holder.toString();
	}

	public void loadExpressionValues(IExpressionDMContext expression, int depth)
	{
		loadExpressionValues(expression, new Integer[] {depth});
	}

	private void loadExpressionValues(IExpressionDMContext expression, final Integer[] depth)
	{
		getExpressionValue(expression);
		if (depth[0] > 0)
		{
			getSubExpressions(expression, new DataRequestMonitor<IExpressions.IExpressionDMContext[]>(ImmediateExecutor.getInstance(), null) {

				@Override
				protected void handleSuccess() {
					depth[0] = depth[0] - 1;
					IExpressions.IExpressionDMContext[] subExpressions = getData();
					for (IExpressionDMContext iExpressionDMContext : subExpressions) {
						loadExpressionValues(iExpressionDMContext, depth);
					}
				}});
		}
	}
}