* Ericsson               - Added support for Mac OS

		if (version.startsWith(LaunchUtils.MACOS_GDB_PREFIX)) {

			// Mac OS's GDB does not support Non-Stop

			return false;

		}

 * Ericsson   - Added support for Mac OS

	/**

	 * A prefix that we use to indicate that a GDB version is for MAC OS

	 * @since 2.1

	 */

	public static final String MACOS_GDB_PREFIX = "APPLE"; //$NON-NLS-1$

import org.eclipse.cdt.dsf.gdb.launching.LaunchUtils;

import org.eclipse.cdt.dsf.gdb.service.macos.MacOSGDBExpressions;

import org.eclipse.cdt.dsf.mi.service.MIExpressions;

	// Contains the GDB version string such as

	// 7.0

	// 6.8.50.20090218

	// For MacOS, it contains the Apple version number, such as

	// 969

	// 1465

	// Indicate if we are dealing with a Mac OS GDB

	private boolean fIsMacOSGdb = false;

		if (fIsMacOSGdb) {

			return new MIBreakpointsManager(session, CDebugCorePlugin.PLUGIN_ID);

		}

		if (fIsMacOSGdb) {

			return new MIBreakpoints(session);

		}

		if (fIsMacOSGdb) {

			return new GDBControl(session, config);

		}

		if (fIsMacOSGdb) {

			return new GDBBackend(session, lc);

		}

		if (fIsMacOSGdb) {

			return new MIDisassembly(session);

		}

		if (fIsMacOSGdb) {

			return new MacOSGDBExpressions(session);

		}

		if (fIsMacOSGdb) {

			return new MIMemory(session);

		}

		if (fIsMacOSGdb) {

			return new MIModules(session);

		}

		if (fIsMacOSGdb) {

			return new GDBProcesses(session);

		}

		if (fIsMacOSGdb) {

			return new MIRegisters(session);

		}

		if (fIsMacOSGdb) {

			return new GDBRunControl(session);

		}

		if (fIsMacOSGdb) {

			return new CSourceLookup(session);

		}

		if (fIsMacOSGdb) {

			return new MIStack(session);

		}

/*******************************************************************************

 * Copyright (c) 2010 Wind River Systems 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:

 *     Wind River Systems - initial API and implementation

 *     Ericsson 		  - Modified for handling of multiple execution contexts

 *     Ericsson           - Created the MacOS version

 *******************************************************************************/

package org.eclipse.cdt.dsf.gdb.service.macos;

import java.util.HashMap;

import java.util.Hashtable;

import java.util.Map;

import org.eclipse.cdt.core.IAddress;

import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;

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.ICachingService;

import org.eclipse.cdt.dsf.debug.service.IExpressions;

import org.eclipse.cdt.dsf.debug.service.IFormattedValues;

import org.eclipse.cdt.dsf.debug.service.IRunControl;

import org.eclipse.cdt.dsf.debug.service.IMemory.IMemoryChangedEvent;

import org.eclipse.cdt.dsf.debug.service.IMemory.IMemoryDMContext;

import org.eclipse.cdt.dsf.debug.service.IRegisters.IRegisterDMContext;

import org.eclipse.cdt.dsf.debug.service.IRunControl.StateChangeReason;

import org.eclipse.cdt.dsf.debug.service.IStack.IFrameDMContext;

import org.eclipse.cdt.dsf.debug.service.command.CommandCache;

import org.eclipse.cdt.dsf.debug.service.command.ICommandControlService;

import org.eclipse.cdt.dsf.gdb.internal.GdbPlugin;

import org.eclipse.cdt.dsf.mi.service.IMIExecutionDMContext;

import org.eclipse.cdt.dsf.mi.service.MIStack;

import org.eclipse.cdt.dsf.mi.service.MIExpressions.ExpressionInfo;

import org.eclipse.cdt.dsf.mi.service.command.commands.ExprMetaGetAttributes;

import org.eclipse.cdt.dsf.mi.service.command.commands.ExprMetaGetChildCount;

import org.eclipse.cdt.dsf.mi.service.command.commands.ExprMetaGetChildren;

import org.eclipse.cdt.dsf.mi.service.command.commands.ExprMetaGetValue;

import org.eclipse.cdt.dsf.mi.service.command.commands.ExprMetaGetVar;

import org.eclipse.cdt.dsf.mi.service.command.commands.MIDataEvaluateExpression;

import org.eclipse.cdt.dsf.mi.service.command.output.ExprMetaGetAttributesInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.ExprMetaGetChildCountInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.ExprMetaGetChildrenInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.ExprMetaGetValueInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.ExprMetaGetVarInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.MIDataEvaluateExpressionInfo;

import org.eclipse.cdt.dsf.service.AbstractDsfService;

import org.eclipse.cdt.dsf.service.DsfServiceEventHandler;

import org.eclipse.cdt.dsf.service.DsfSession;

import org.eclipse.cdt.utils.Addr32;

import org.eclipse.cdt.utils.Addr64;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.osgi.framework.BundleContext;

/**

 * This class implements a debugger expression evaluator as a DSF service. The

 * primary interface that clients of this class should use is IExpressions.

 * 

 * This class used to be name ExpressionService in the 1.1 release.

 * 

 * @since 2.1

 */

public class MacOSGDBExpressions extends AbstractDsfService implements IExpressions, ICachingService {

    /**

     * This class represents an expression.

     */

    protected static class MIExpressionDMC extends AbstractDMContext implements IExpressionDMContext {

        /**

         * This field holds an expression to be evaluated.

         */

    	private ExpressionInfo exprInfo;

        /**

         * ExpressionDMC Constructor for expression to be evaluated in context of 

         * a stack frame.

         * 

         * @param sessionId

         *            The session ID in which this context is created.

         * @param expression

         *            The expression to be described by this ExpressionDMC

         * @param relExpr

         *            The relative expression if this expression was created as a child

         * @param frameCtx

         *            The parent stack frame context for this ExpressionDMC. 

         */

        public MIExpressionDMC(String sessionId, String expression, String relExpr, IFrameDMContext frameCtx) {

            this(sessionId, expression, relExpr, (IDMContext)frameCtx);

        }

       /**

         * ExpressionDMC Constructor for expression to be evaluated in context of 

         * an thread.

         * 

         * @param sessionId

         *            The session ID in which this context is created.

         * @param expression

         *            The expression to be described by this ExpressionDMC

         * @param relExpr

         *            The relative expression if this expression was created as a child

         * @param execCtx

         *            The parent thread context for this ExpressionDMC. 

         */

        public MIExpressionDMC(String sessionId, String expression, String relExpr, IMIExecutionDMContext execCtx) {

            this(sessionId, expression, relExpr, (IDMContext)execCtx);

        }

        /**

         * ExpressionDMC Constructor for expression to be evaluated in context of 

         * a memory space.

         * 

         * @param sessionId

         *            The session ID in which this context is created.

         * @param expression

         *            The expression to be described by this ExpressionDMC

         * @param relExpr

         *            The relative expression if this expression was created as a child

         * @param memoryCtx

         *            The parent memory space context for this ExpressionDMC. 

         */

        public MIExpressionDMC(String sessionId, String expression, String relExpr, IMemoryDMContext memoryCtx) {

            this(sessionId, expression, relExpr, (IDMContext)memoryCtx);

        }

        private MIExpressionDMC(String sessionId, String expr, String relExpr, IDMContext parent) {

            super(sessionId, new IDMContext[] { parent });

            exprInfo = new ExpressionInfo(expr, relExpr);

        }

        /**

         * @return True if the two objects are equal, false otherwise.

         */

        @Override

        public boolean equals(Object other) {

            return super.baseEquals(other) && exprInfo.equals(((MIExpressionDMC)other).exprInfo);

        }

        /**

         * 

         * @return The hash code of this ExpressionDMC object.

         */

        @Override

        public int hashCode() {

            return super.baseHashCode() + exprInfo.hashCode();

        }

        /**

         * 

         * @return A string representation of this ExpressionDMC (including the

         *         expression to which it is bound).

         */

        @Override

        public String toString() {

            return baseToString() + ".expr" + exprInfo.toString(); //$NON-NLS-1$ 

        }

        /**

         * @return The full expression string represented by this ExpressionDMC

         */

        public String getExpression() {

            return exprInfo.getFullExpr();

        }

        /**

         * @return The relative expression string represented by this ExpressionDMC

         */

        public String getRelativeExpression() {

            return exprInfo.getRelExpr();

        }

    }

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

        }

    }

	/**

	 * Contains the address of an expression as well as the size of its type.

	 */

    private static class ExpressionDMAddress implements IExpressionDMAddress {

    	IAddress fAddr;

    	int fSize;

    	public ExpressionDMAddress(IAddress addr, int size) {

    		fAddr = addr;

    		fSize = size;

    	}

    	public ExpressionDMAddress(String addrStr, int size) {

    		fSize = size;

    		// We must count the "0x" and that

    		// is why we compare with 10 characters

    		// instead of 8

    		if (addrStr.length() <= 10) {

    			fAddr = new Addr32(addrStr);

    		} else {

    			fAddr = new Addr64(addrStr);

    		}

    	}

    	public IAddress getAddress() { return fAddr; }

    	public int getSize() { return fSize; }

		@Override

		public boolean equals(Object other) {

			if (other instanceof ExpressionDMAddress) {

				ExpressionDMAddress otherAddr = (ExpressionDMAddress) other;

				return (fSize == otherAddr.getSize()) && 

    				(fAddr == null ? otherAddr.getAddress() == null : fAddr.equals(otherAddr.getAddress()));

			}

			return false;

		}

		@Override

		public int hashCode() {

			return (fAddr == null ? 0 :fAddr.hashCode()) + fSize;

		}

		@Override

		public String toString() {

			return (fAddr == null ? "null" : "(0x" + fAddr.toString()) + ", " + fSize + ")"; //$NON-NLS-1$ //$NON-NLS-2$//$NON-NLS-3$//$NON-NLS-4$

		}

    }

	/**

	 * This class represents the static data referenced by an instance of ExpressionDMC,

	 * such as its type and number of children; it does not contain the value or format

	 * of the expression.

	 */

    private static class ExpressionDMData implements IExpressionDMData {

		// This is the relative expression, such as the name of a field within a structure,

		// in contrast to the fully-qualified expression contained in the ExpressionDMC,

		// which refers to the full name, including parent structure.

		private final String relativeExpression;

		private final String exprType;

		private final int numChildren;

		private final boolean editable;

		/**

		 * ExpressionDMData constructor.

		 */

		public ExpressionDMData(String expr, String type, int num, boolean edit) {

			relativeExpression = expr;

			exprType = type;

			numChildren = num;

			editable = edit;

		}

		public BasicType getBasicType() {

			return null;

		}

		public String getEncoding() {

			return null;

		}

		public Map<String, Integer> getEnumerations() {

			return new HashMap<String, Integer>();

		}

		public String getName() {

			return relativeExpression;

		}

		public IRegisterDMContext getRegister() {

			return null;

		}

		// See class VariableVMNode for an example of usage of this method

		public String getStringValue() {

			return null;

		}

		public String getTypeId() {

			return null;

		}

		public String getTypeName() {

			return exprType;

		}

		public int getNumChildren() {

			return numChildren;	

		}

		public boolean isEditable() {

			return editable;

		}

		@Override

		public boolean equals(Object other) {

			if (other instanceof ExpressionDMData) {

				ExpressionDMData otherData = (ExpressionDMData) other;

				return (getNumChildren() == otherData.getNumChildren()) && 

    				(getTypeName() == null ? otherData.getTypeName() == null : getTypeName().equals(otherData.getTypeName())) &&

    				(getName() == null ? otherData.getName() == null : getName().equals(otherData.getName()));

			}

			return false;

		}

		@Override

		public int hashCode() {

			return relativeExpression == null ? 0 : relativeExpression.hashCode() + 

					exprType == null ? 0 : exprType.hashCode() + numChildren;

		}

		@Override

		public String toString() {

			return "relExpr=" + relativeExpression + ", type=" + exprType + ", numchildren=" + numChildren; //$NON-NLS-1$ //$NON-NLS-2$//$NON-NLS-3$

		}

	}

	/**

	 * Event generated every time an expression is changed by the ExpressionService.

	 * 

	 * A client wishing to receive such events has to register as a service

	 * event listener and implement the corresponding eventDispatched method.

	 * 

	 * E.g.:

	 *

	 *    getSession().addServiceEventListener(listenerObject, null);

	 *     

	 *    @DsfServiceEventHandler

	 *    public void eventDispatched(ExpressionChangedEvent e) {

	 *       IExpressionDMContext context = e.getDMContext();

	 *       // do something...

	 *    }

	 */

    private static class ExpressionChangedEvent extends AbstractDMEvent<IExpressionDMContext>

                        implements IExpressionChangedDMEvent {

        public ExpressionChangedEvent(IExpressionDMContext context) {

        	super(context);

        }

    }

	private CommandCache fExpressionCache;

	private MacOSGDBVariableManager varManager;

	public MacOSGDBExpressions(DsfSession session) {

		super(session);

	}

	/**

	 * This method initializes this service.

	 * 

	 * @param requestMonitor

	 *            The request monitor indicating the operation is finished

	 */

	@Override

	public void initialize(final RequestMonitor requestMonitor) {

		super.initialize(new RequestMonitor(getExecutor(), requestMonitor) {

			@Override

			protected void handleSuccess() {

				doInitialize(requestMonitor);

			}

		});

	}

	/**

	 * This method initializes this service after our superclass's initialize()

	 * method succeeds.

	 * 

	 * @param requestMonitor

	 *            The call-back object to notify when this service's

	 *            initialization is done.

	 */

	private void doInitialize(RequestMonitor requestMonitor) {

		// Register to receive service events for this session.

        getSession().addServiceEventListener(this, null);

		// Register this service.

		register(new String[] { IExpressions.class.getName(),

				MacOSGDBExpressions.class.getName() },

				new Hashtable<String, String>());

		// Create the expressionService-specific CommandControl which is our

        // variable object manager.

        // It will deal with the meta-commands, before sending real MI commands

        // to the back-end, through the MICommandControl service

		// It must be created after the ExpressionService is registered

		// since it will need to find it.

        varManager = new MacOSGDBVariableManager(getSession(), getServicesTracker());

        // Create the meta command cache which will use the variable manager

        // to actually send MI commands to the back-end

        fExpressionCache = new CommandCache(getSession(), varManager);

        ICommandControlService commandControl = getServicesTracker().getService(ICommandControlService.class);

        fExpressionCache.setContextAvailable(commandControl.getContext(), true);

		requestMonitor.done();

	}

	/**

	 * This method shuts down this service. It unregisters the service, stops

	 * receiving service events, and calls the superclass shutdown() method to

	 * finish the shutdown process.

	 * 

	 * @return void

	 */

	@Override

	public void shutdown(RequestMonitor requestMonitor) {

		unregister();

		varManager.dispose();

		getSession().removeServiceEventListener(this);

		super.shutdown(requestMonitor);

	}

	/**

	 * @return The bundle context of the plug-in to which this service belongs.

	 */

	@Override

	protected BundleContext getBundleContext() {

		return GdbPlugin.getBundleContext();

	}

	/**

	 * Create an expression context with the same full and relative expression

	 */

	public IExpressionDMContext createExpression(IDMContext ctx, String expression) {

		return createExpression(ctx, expression, expression);

	}

	/**

	 * Create an expression context.

	 */

	public IExpressionDMContext createExpression(IDMContext ctx, String expression, String relExpr) {

	    IFrameDMContext frameDmc = DMContexts.getAncestorOfType(ctx, IFrameDMContext.class);

	    if (frameDmc != null) {

	        return new MIExpressionDMC(getSession().getId(), expression, relExpr, frameDmc);

	    } 

	    IMIExecutionDMContext execCtx = DMContexts.getAncestorOfType(ctx, IMIExecutionDMContext.class);

	    if (execCtx != null) {

	    	// If we have a thread context but not a frame context, we give the user

	    	// the expression as per the top-most frame of the specified thread.

	    	// To do this, we create our own frame context.

	    	MIStack stackService = getServicesTracker().getService(MIStack.class);

	    	if (stackService != null) {

	    		frameDmc = stackService.createFrameDMContext(execCtx, 0);

	            return new MIExpressionDMC(getSession().getId(), expression, relExpr, frameDmc);

	    	}

            return new InvalidContextExpressionDMC(getSession().getId(), expression, execCtx);

        } 

        IMemoryDMContext memoryCtx = DMContexts.getAncestorOfType(ctx, IMemoryDMContext.class);

        if (memoryCtx != null) {

            return new MIExpressionDMC(getSession().getId(), expression, relExpr, memoryCtx);

        } 

        // Don't care about the relative expression at this point

        return new InvalidContextExpressionDMC(getSession().getId(), expression, ctx);

	}

	/**

	 * @see IFormattedValues.getFormattedValueContext(IFormattedDataDMContext, String)

	 * 

	 * @param dmc

	 *            The context describing the data for which we want to create

	 *            a Formatted context.

	 * @param formatId

	 *            The format that will be used to create the Formatted context

	 *            

	 * @return A FormattedValueDMContext that can be used to obtain the value

	 *         of an expression in a specific format. 

	 */

	public FormattedValueDMContext getFormattedValueContext(

			IFormattedDataDMContext dmc, String formatId) {

		return new FormattedValueDMContext(this, dmc, formatId);

	}

	/**

	 * @see IFormattedValues.getAvailableFormats(IFormattedDataDMContext, DataRequestMonitor)

	 * 

	 * @param dmc

	 *            The context describing the data for which we want to know

	 *            which formats are available.

	 * @param rm

	 *            The data request monitor for this asynchronous operation. 

	 *  

	 */

	public void getAvailableFormats(IFormattedDataDMContext dmc,

			final DataRequestMonitor<String[]> rm) {

		rm.setData(new String[] { IFormattedValues.BINARY_FORMAT,

				IFormattedValues.NATURAL_FORMAT, IFormattedValues.HEX_FORMAT,

				IFormattedValues.OCTAL_FORMAT, IFormattedValues.DECIMAL_FORMAT });

		rm.done();

	}

	/**

	 * Obtains the static data of an expression represented 

	 * by an ExpressionDMC object (<tt>dmc</tt>).

	 * 

	 * @param dmc

	 *            The ExpressionDMC for the expression to be evaluated.

	 * @param rm

	 *            The data request monitor that will contain the requested data

	 */

	public void getExpressionData(

			final IExpressionDMContext dmc,

			final DataRequestMonitor<IExpressionDMData> rm) 

	{

	    if (dmc instanceof MIExpressionDMC) {

    		fExpressionCache.execute(

    				new ExprMetaGetVar(dmc), 

    				new DataRequestMonitor<ExprMetaGetVarInfo>(getExecutor(), rm) {

    					@Override

    					protected void handleSuccess() {

    						rm.setData(new ExpressionDMData(getData().getExpr(), 

    								getData().getType(), getData().getNumChildren(), getData().getEditable()));

    						rm.done();

    					}

    				});

	    } else if (dmc instanceof InvalidContextExpressionDMC) {

            rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid context for evaluating expressions.", null)); //$NON-NLS-1$

            rm.done();

	    } else {

            rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Invalid expression context.", null)); //$NON-NLS-1$

            rm.done();

	    }

	}

	/**

	 * Obtains the address of an expression and the size of its type. 

	 * 

	 * @param dmc

	 *            The ExpressionDMC for the expression.

	 * @param rm

	 *            The data request monitor that will contain the requested data

	 */

    public void getExpressionAddressData(

    		IExpressionDMContext dmc, 

    		final DataRequestMonitor<IExpressionDMAddress> rm) {

    	// First create an address expression and a size expression

    	// to be used in back-end calls

    	final IExpressionDMContext addressDmc = 

    	    createExpression( dmc, "&(" + dmc.getExpression() + ")" );//$NON-NLS-1$//$NON-NLS-2$

    	final IExpressionDMContext sizeDmc = 

    	    createExpression( dmc, "sizeof(" + dmc.getExpression() + ")" ); //$NON-NLS-1$//$NON-NLS-2$

    	if (addressDmc instanceof InvalidContextExpressionDMC || sizeDmc instanceof InvalidContextExpressionDMC) {

            rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid context for evaluating expressions.", null)); //$NON-NLS-1$

            rm.done();

    	} else {

        	fExpressionCache.execute(

    			new MIDataEvaluateExpression<MIDataEvaluateExpressionInfo>(addressDmc), 

    			new DataRequestMonitor<MIDataEvaluateExpressionInfo>(getExecutor(), rm) {

    				@Override

    				protected void handleSuccess() {

    					String tmpAddrStr = getData().getValue();

    					// Deal with adresses of contents of a char* which is in

    					// the form of "0x12345678 \"This is a string\""

    					int split = tmpAddrStr.indexOf(' '); 

    			    	if (split != -1) tmpAddrStr = tmpAddrStr.substring(0, split);

    			    	final String addrStr = tmpAddrStr;

    					fExpressionCache.execute(

    						new MIDataEvaluateExpression<MIDataEvaluateExpressionInfo>(sizeDmc), 

    						new DataRequestMonitor<MIDataEvaluateExpressionInfo>(getExecutor(), rm) {

    							@Override

    							protected void handleSuccess() {

    								try {

    									int size = Integer.parseInt(getData().getValue());

    									rm.setData(new ExpressionDMAddress(addrStr, size));

    								} catch (NumberFormatException e) {

    						            rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INVALID_HANDLE,

    						            		"Unexpected size format from backend: " + getData().getValue(), null)); //$NON-NLS-1$

    								}

    								rm.done();

    							}

    						});

    				}

    			});

    	}

	}

	/**

	 * Obtains the value of an expression in a specific format.

	 * 

	 * @param dmc

	 *            The context for the format of the value requested and 

	 *            for the expression to be evaluated.  The expression context

	 *            should be a parent of the FormattedValueDMContext.

	 * @param rm

	 *            The data request monitor that will contain the requested data

	 */

	public void getFormattedExpressionValue(

			final FormattedValueDMContext dmc,

			final DataRequestMonitor<FormattedValueDMData> rm) 

	{

		// We need to make sure the FormattedValueDMContext also holds an ExpressionContext,

		// or else this method cannot do its work.

		// Note that we look for MIExpressionDMC and not IExpressionDMC, because getting

		// looking for IExpressionDMC could yield InvalidContextExpressionDMC which is still

		// not what we need to have.

        if (DMContexts.getAncestorOfType(dmc, MIExpressionDMC.class) == null ) {

        	rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid context for evaluating expressions.", null)); //$NON-NLS-1$

        	rm.done();

        } else {

        	fExpressionCache.execute(

        			new ExprMetaGetValue(dmc),

        			new DataRequestMonitor<ExprMetaGetValueInfo>(getExecutor(), rm) {

        				@Override

        				protected void handleSuccess() {

        					rm.setData(new FormattedValueDMData(getData().getValue()));

        					rm.done();

        				}

        			});

        }

	}

	/* Not implemented

	 * 

	 * (non-Javadoc)

	 * @see org.eclipse.cdt.dsf.debug.service.IExpressions#getBaseExpressions(org.eclipse.cdt.dsf.debug.service.IExpressions.IExpressionDMContext, org.eclipse.cdt.dsf.concurrent.DataRequestMonitor)

	 */

	public void getBaseExpressions(IExpressionDMContext exprContext,

			DataRequestMonitor<IExpressionDMContext[]> rm) {

		rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID,

				NOT_SUPPORTED, "Not supported", null)); //$NON-NLS-1$

		rm.done();

	}

	/**

	 * Retrieves the children expressions of the specified expression

	 * 

	 * @param exprCtx

	 *            The context for the expression for which the children

	 *            should be retrieved.

	 * @param rm

	 *            The data request monitor that will contain the requested data

	 */

	public void getSubExpressions(final IExpressionDMContext dmc,

			final DataRequestMonitor<IExpressionDMContext[]> rm) 

	{		

		if (dmc instanceof MIExpressionDMC) {

			fExpressionCache.execute(

					new ExprMetaGetChildren(dmc),				

					new DataRequestMonitor<ExprMetaGetChildrenInfo>(getExecutor(), rm) {

						@Override

						protected void handleSuccess() {

							ExpressionInfo[] childrenExpr = getData().getChildrenExpressions();

							IExpressionDMContext[] childArray = new IExpressionDMContext[childrenExpr.length];

							for (int i=0; i<childArray.length; i++) {

								childArray[i] = createExpression(

										dmc.getParents()[0], 

										childrenExpr[i].getFullExpr(),

										childrenExpr[i].getRelExpr());

							}

							rm.setData(childArray);

							rm.done();

						}

					});

		} else if (dmc instanceof InvalidContextExpressionDMC) {

			rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid context for evaluating expressions.", null)); //$NON-NLS-1$

			rm.done();

		} else {

			rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Invalid expression context.", null)); //$NON-NLS-1$

			rm.done();

		}

	}

	/**

	 * Retrieves a range of children expressions of the specified expression

	 * 

	 * @param exprCtx

	 *            The context for the expression for which the children

	 *            should be retrieved.

	 * @param startIndex

	 *            The starting index within the list of all children of the parent

	 *            expression.  Must be a positive integer.  

	 * @param length

	 *            The length or number of elements of the range requested.  

	 *            Must be a positive integer.

	 * @param rm

	 *            The data request monitor that will contain the requested data

	 */

	public void getSubExpressions(IExpressionDMContext exprCtx, final int startIndex,

			final int length, final DataRequestMonitor<IExpressionDMContext[]> rm) {

		if (startIndex < 0 || length < 0) {

			rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Invalid range for evaluating sub expressions.", null)); //$NON-NLS-1$

			rm.done();

			return;

		}

		if (exprCtx instanceof MIExpressionDMC) {

			getSubExpressions(

					exprCtx,

					new DataRequestMonitor<IExpressionDMContext[]>(getExecutor(), rm) {

						@Override

						protected void handleSuccess() {

							IExpressionDMContext[] subExpressions = getData();

							if (startIndex >= subExpressions.length || startIndex + length > subExpressions.length) {

								rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, REQUEST_FAILED, "Invalid range for evaluating sub expressions.", null)); //$NON-NLS-1$

								rm.done();

								return;

							}

							IExpressionDMContext[] subRange = new IExpressionDMContext[length];

							for (int i=0; i<subRange.length; i++) {

								subRange[i] = subExpressions[i+startIndex]; 

							}

							rm.setData(subRange);

							rm.done();

						}

					});

		} else if (exprCtx instanceof InvalidContextExpressionDMC) {

			rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid context for evaluating expressions.", null)); //$NON-NLS-1$

			rm.done();

		} else {

			rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Invalid expression context.", null)); //$NON-NLS-1$

			rm.done();

		}		

	}

	/**

	 * Retrieves the count of children expressions of the specified expression

	 * 

	 * @param exprCtx

	 *            The context for the expression for which the children count

	 *            should be retrieved.

	 * @param rm

	 *            The data request monitor that will contain the requested data

	 */

	public void getSubExpressionCount(IExpressionDMContext dmc,

			final DataRequestMonitor<Integer> rm) 

	{

		if (dmc instanceof MIExpressionDMC) {

			fExpressionCache.execute(

					new ExprMetaGetChildCount(dmc),				

					new DataRequestMonitor<ExprMetaGetChildCountInfo>(getExecutor(), rm) {

						@Override

						protected void handleSuccess() {

							rm.setData(getData().getChildNum());

							rm.done();

						}

					});

		} else if (dmc instanceof InvalidContextExpressionDMC) {

			rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid context for evaluating expressions.", null)); //$NON-NLS-1$

			rm.done();

		} else {

			rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Invalid expression context.", null)); //$NON-NLS-1$

			rm.done();

		}

	}

    /**

     * This method indicates if an expression can be written to.

     * 

     * @param dmc: The data model context representing an expression.

     *

     * @param rm: Data Request monitor containing True if this expression's value can be edited.  False otherwise.

     */

	public void canWriteExpression(IExpressionDMContext dmc, final DataRequestMonitor<Boolean> rm) {

        if (dmc instanceof MIExpressionDMC) {

            fExpressionCache.execute(

                    new ExprMetaGetAttributes(dmc),

                    new DataRequestMonitor<ExprMetaGetAttributesInfo>(getExecutor(), rm) {

                        @Override

                        protected void handleSuccess() {

                            rm.setData(getData().getEditable());

                            rm.done();

                        }

                    });

        } else if (dmc instanceof InvalidContextExpressionDMC) {

            rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid context for evaluating expressions.", null)); //$NON-NLS-1$

            rm.done();

        } else {

            rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Invalid expression context.", null)); //$NON-NLS-1$

            rm.done();

        }

	}

	/**

	 * Changes the value of the specified expression based on the new value and format.

	 * 

	 * @param expressionContext

	 *            The context for the expression for which the value 

	 *            should be changed.

	 * @param expressionValue

	 *            The new value for the specified expression

	 * @param formatId

	 *            The format in which the value is specified

	 * @param rm

	 *            The request monitor that will indicate the completion of the operation

	 */

	public void writeExpression(final IExpressionDMContext dmc, String expressionValue, 

			String formatId, final RequestMonitor rm) {

		if (dmc instanceof MIExpressionDMC) {

			// This command must not be cached, since it changes the state of the back-end.

			// We must send it directly to the variable manager

			varManager.writeValue(

			        dmc, 

					expressionValue, 

					formatId, 

					new RequestMonitor(getExecutor(), rm) {

						@Override

						protected void handleSuccess() {

							// A value has changed, we should remove any references to that

							// value in our cache.  Since we don't have such granularity,

							// we must clear the entire cache.

							// We cannot use the context to do a more-specific reset, because

							// the same global variable can be set with different contexts

							fExpressionCache.reset();

							// Issue event that the expression has changed

							getSession().dispatchEvent(new ExpressionChangedEvent(dmc), getProperties());

							rm.done();

						}

					});

		} else if (dmc instanceof InvalidContextExpressionDMC) {

			rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid context for evaluating expressions.", null)); //$NON-NLS-1$

			rm.done();

		} else {

			rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Invalid expression context.", null)); //$NON-NLS-1$

			rm.done();

		}

	}

    @DsfServiceEventHandler 

    public void eventDispatched(IRunControl.IResumedDMEvent e) {

        fExpressionCache.setContextAvailable(e.getDMContext(), false);

        if (e.getReason() != StateChangeReason.STEP) {

            fExpressionCache.reset();

        }

    }

    @DsfServiceEventHandler 

    public void eventDispatched(IRunControl.ISuspendedDMEvent e) {

        fExpressionCache.setContextAvailable(e.getDMContext(), true);

        fExpressionCache.reset();

    }

    @DsfServiceEventHandler 

    public void eventDispatched(IMemoryChangedEvent e) {

        fExpressionCache.reset();

        // VariableManager separately traps this event

    }

    public void flushCache(IDMContext context) {

        fExpressionCache.reset(context);

        // We must also mark all variable objects as out-of-date

        // to refresh them as well

        varManager.markAllOutOfDate();

    }

}

/*******************************************************************************

 * Copyright (c) 2010 Monta Vista 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:

 *     Monta Vista - initial API and implementation

 *     Ericsson    - Modified for handling of multiple execution contexts

 *     Ericsson    - Major updates for GDB/MI implementation

 *     Ericsson    - Major re-factoring to deal with children

 *     Ericsson           - Created the MacOS version

 *******************************************************************************/

package org.eclipse.cdt.dsf.gdb.service.macos;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import org.eclipse.cdt.dsf.concurrent.CountingRequestMonitor;

import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;

import org.eclipse.cdt.dsf.concurrent.IDsfStatusConstants;

import org.eclipse.cdt.dsf.concurrent.RequestMonitor;

import org.eclipse.cdt.dsf.datamodel.DMContexts;

import org.eclipse.cdt.dsf.debug.service.IExpressions;

import org.eclipse.cdt.dsf.debug.service.IFormattedValues;

import org.eclipse.cdt.dsf.debug.service.IRunControl;

import org.eclipse.cdt.dsf.debug.service.IStack;

import org.eclipse.cdt.dsf.debug.service.IExpressions.IExpressionDMContext;

import org.eclipse.cdt.dsf.debug.service.IFormattedValues.FormattedValueDMContext;

import org.eclipse.cdt.dsf.debug.service.IFormattedValues.FormattedValueDMData;

import org.eclipse.cdt.dsf.debug.service.IMemory.IMemoryChangedEvent;

import org.eclipse.cdt.dsf.debug.service.IRunControl.IExecutionDMContext;

import org.eclipse.cdt.dsf.debug.service.IStack.IFrameDMContext;

import org.eclipse.cdt.dsf.debug.service.command.ICommand;

import org.eclipse.cdt.dsf.debug.service.command.ICommandControl;

import org.eclipse.cdt.dsf.debug.service.command.ICommandListener;

import org.eclipse.cdt.dsf.debug.service.command.ICommandResult;

import org.eclipse.cdt.dsf.debug.service.command.ICommandToken;

import org.eclipse.cdt.dsf.debug.service.command.IEventListener;

import org.eclipse.cdt.dsf.debug.service.command.ICommandControlService.ICommandControlDMContext;

import org.eclipse.cdt.dsf.gdb.internal.GdbPlugin;

import org.eclipse.cdt.dsf.gdb.service.macos.MacOSGDBExpressions.MIExpressionDMC;

import org.eclipse.cdt.dsf.mi.service.MIExpressions.ExpressionInfo;

import org.eclipse.cdt.dsf.mi.service.command.commands.ExprMetaGetAttributes;

import org.eclipse.cdt.dsf.mi.service.command.commands.ExprMetaGetChildCount;

import org.eclipse.cdt.dsf.mi.service.command.commands.ExprMetaGetChildren;

import org.eclipse.cdt.dsf.mi.service.command.commands.ExprMetaGetValue;

import org.eclipse.cdt.dsf.mi.service.command.commands.ExprMetaGetVar;

import org.eclipse.cdt.dsf.mi.service.command.commands.MIDataEvaluateExpression;

import org.eclipse.cdt.dsf.mi.service.command.commands.MIVarAssign;

import org.eclipse.cdt.dsf.mi.service.command.commands.MIVarCreate;

import org.eclipse.cdt.dsf.mi.service.command.commands.MIVarDelete;

import org.eclipse.cdt.dsf.mi.service.command.commands.MIVarEvaluateExpression;

import org.eclipse.cdt.dsf.mi.service.command.commands.MIVarInfoPathExpression;

import org.eclipse.cdt.dsf.mi.service.command.commands.MIVarListChildren;

import org.eclipse.cdt.dsf.mi.service.command.commands.MIVarSetFormat;

import org.eclipse.cdt.dsf.mi.service.command.commands.MIVarShowAttributes;

import org.eclipse.cdt.dsf.mi.service.command.commands.macos.MacOSMIVarUpdate;

import org.eclipse.cdt.dsf.mi.service.command.output.ExprMetaGetAttributesInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.ExprMetaGetChildCountInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.ExprMetaGetChildrenInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.ExprMetaGetValueInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.ExprMetaGetVarInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.MIVar;

import org.eclipse.cdt.dsf.mi.service.command.output.MIVarAssignInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.MIVarChange;

import org.eclipse.cdt.dsf.mi.service.command.output.MIVarCreateInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.MIVarDeleteInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.MIVarEvaluateExpressionInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.MIVarInfoPathExpressionInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.MIVarListChildrenInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.MIVarSetFormatInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.MIVarShowAttributesInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.macos.MacOSMIVarUpdateInfo;

import org.eclipse.cdt.dsf.service.DsfServiceEventHandler;

import org.eclipse.cdt.dsf.service.DsfServicesTracker;

import org.eclipse.cdt.dsf.service.DsfSession;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

/**

 * Manages a list of variable objects as created through GDB/MI commands.

 * 

 * This class is passed expression-meta-commands which have their own cache.

 * Therefore, we don't use the standard MICommandCache in this class.

 * In fact, we can't even use it, because many variableObject MI commands,

 * should not be cached as they alter the state of the back-end.

 * 

 * Design details:

 * ==============

 * 

 * GDB variable object information

 * -------------------------------

 * o Variable objects are recursively hierarchical, where children can be created through 

 *   the parent.

 * o A varObject created with -var-create is a ROOT

 * o A varObject created with -var-list-children, is not a root

 * o Only varObject with no children or varObjects that are pointers can change values 

 *   and therefore 

 *   those objects can be used with -var-assign

 * o After a program stops, a varObject must be 'updated' before used 

 * o Only root varObject can be updated with -var-update, which will trigger all

 *   of the root's descendants to be updated.

 * o Once updated, a varObject need not be updated until the program resumes again;

 *   this is true even after -var-assign is used (because it does an implicit -var-update)

 * o -var-update will return the list of all modifiable descendants of the udpated root which

 *   have changed

 * o -var-update will indicate if a root is out-of-scope (which implies that all

 *   its descendants are out-of-scope)

 * o if a varObject is out-of-scope, another varObject may be valid for the same

 *   expression as the out-of-scope varObject

 * o deleting a varObject will delete all its descendants, therefore, it is only

 *   necessary to delete roots

 * 

 * 

 * Class details

 * -------------

 * - We have an MIVariableObject class which represents a variable object in GDB

 * 

 * - MIVariableObject includes a buffered value for each allowed format.

 * 

 * - We have an MIRootVariableObject class inheriting from MIVariableObject to describe

 *   root varObjects created with -var-create.  Objects created with -var-list-children

 *   are MIVariableObjects only.  The root class will keep track of if the root object 

 *   needs to be updated, if the root object is out-of-scope, and of a list of all 

 *   modifiable descendants of this root.  The list of modifiable descendants is 

 *   accessed using the gdb-given name to allow quick updates from the -var-update 

 *   result (see below.)

 * 

 * - we do not use -var-list-children for arrays, but create them manually

 *  

 * - when the program stops, we should mark all roots as needing to be updated. 

 * To achieve this efficiently, we have a dedicated list of roots that are updated.

 * When the program stops, we go through this list, remove each element and mark it

 * as needing to be updated.

 * 

 * - when a varObject is accessed, if its root must be updated, the var-update

 * command shall be used.  The result of that command will indicate all

 * modifiable descendants that have changed.  We also use --all-values with -var-update

 * to get the new value (in the current format) for each modified descendant.  Using the list of modifiable

 * descendants of the root, we can quickly update the changed ones to invalidate their buffered

 * values and store the new current format value.

 * 

 * - all values of non-modifiable varObjects (except arrays) will be set to {...}

 * without going to the back-end

 * 

 * - requesting the value of an array varObject will trigger the creation of a new

 * varObject for the array's address.  Note that we must still use a variable

 * object and not the command -data-evaluate-expression, because we still need to get

 * the array address in multiple formats.

 * 

 * - we keep an LRU (Least Recently Used) structure of all variable objects.  This LRU

 * will be bounded to a maximum allowed number of variable objects.  Whenever we get an

 * object from the LRU cleanup will be done if the maximum size has been reached.

 * The LRU will not delete a parent varObject until all its children are deleted; this is

 * achieved by touching each of the parents of an object whenever that object is put or get

 *

 * - It may happen that when accessing a varObject we find its root to be

 * out-of-scope.  The expression for which we are trying to access a varObject

 * could still be valid, and therefore we should try to create a new varObject for

 * that expression.  This can happen for example if two methods use the same name

 * for a variable. In the case when we find that a varObject is out-of-scope (when

 * its root is out-of-scope) the following should be done:

 *  - replace the varObject in the LRU with a newly created one in GDB

 *  - if the old object was a root, delete it in GDB.

 *  

 * - In GDB, -var-update will only report a change if -var-evaluate-expression has

 *   changed -- in the current format--.  This means that situations like

 *    double z = 1.2;

 *    z = 1.4;

 *   Will not report a change if the format is anything else than natural.

 *   This is because 1.2 and 1.4 are both printed as 1, 0x1, etc

 *   Since we cache the values of every format, we must know if the value has

 *   change in -any- format, not just the current one.

 *   To solve this, we always keep the display format of variable objects (and their

 *   children) to the natural format; we believe that if the value changes in any

 *   format, it guarantees that it will change in the natural format.

 *   The simplest way to do this is that whenever we change the format

 *   of a variable object, we immediately set it back to natural with a second

 *   var-set-format command.

 *   Note that versions of GDB after 6.7 will allows to issue -var-evaluate-expression

 *   with a specified format, therefore allowing us to never use -var-set-format, and

 *   consequently, to easily keep the display format of all variable objects to natural.

 *   

 *   @since 2.1

 */

public class MacOSGDBVariableManager implements ICommandControl {

	/**

	 * Utility class to track the progress and information of MI variable objects

	 */

	public class MIVariableObject {

		// Don't use an enumeration to allow subclasses to extend this

		protected static final int STATE_READY = 0;

		protected static final int STATE_UPDATING = 1;

		protected int currentState;	

		// This is the lock used when we must run multiple

		// operations at once.  This lock should be independent of the

		// UPDATING state, which is why we don't make it part of the state

		private boolean locked = false;

	    // This id is the one used to search for this object in our hash-map

	    private final VariableObjectId internalId;

	    // This is the name of the variable object, as given by GDB (e.g., var1 or var1.public.x)

		private String gdbName = null;

		// The current format of this variable object, within GDB

		private String format = IFormattedValues.NATURAL_FORMAT;

		// The full expression that can be used to characterize this object

		private String fullExp = null;

		private String type = null;

		private int numChildren = 0;

		private Boolean editable = null;

		// The current values of the expression for each format. (null if not known yet)

		private Map<String, String> valueMap = null;

		// A queue of request monitors waiting for this object to be ready

		private LinkedList<RequestMonitor> operationsPending;

		// A queue of request monitors that requested an update

		protected LinkedList<DataRequestMonitor<Boolean>> updatesPending;

		// The relative expressions of the children of this variable, if any.  

		// Null means we didn't fetch them yet, while an empty array means no children

        private ExpressionInfo[] children = null; 

        // The parent of this variable object within GDB.  Null if this object has no parent

        private MIVariableObject parent = null;

        // The root parent that must be used to issue -var-update.

        // If this object is a root, then the rootToUpdate is itself

        private MIRootVariableObject rootToUpdate = null;

		protected boolean outOfScope = false;

		public MIVariableObject(VariableObjectId id, MIVariableObject parentObj) {

			currentState = STATE_READY;

			operationsPending = new LinkedList<RequestMonitor>();

			updatesPending = new LinkedList<DataRequestMonitor<Boolean>>();

			internalId = id;

			setParent(parentObj);

			// No values are available yet

			valueMap = new HashMap<String, String>();

			resetValues();

		}

		public VariableObjectId getInternalId() { return internalId; }

		public String getGdbName() { return gdbName; }

		public String getCurrentFormat() {	return format; }

		public MIVariableObject getParent() { return parent; }

		public MIRootVariableObject getRootToUpdate() { return rootToUpdate; }

		public String getExpression() { return fullExp; }

		public String getType() { return type; }

		public int getNumChildren() { return numChildren; }

		public String getValue(String format) { return valueMap.get(format); }

        public ExpressionInfo[] getChildren() { return children; }

        //FIX replace these methods with CDT's GDBTypeParser (see bug 200897 comment #5)

        // int(*)[5] is a pointer to an array (so it is a pointer but not an array) (e.g., &b where int b[5])

        // int *[5] is an array of pointers (so it is an array but not a pointer) (e.g., int *b[5])

		public boolean isArray() { return (getType() == null) ? false : getType().endsWith("]") && !getType().contains("(*)") ; }//$NON-NLS-1$//$NON-NLS-2$

		public boolean isPointer() { return (getType() == null) ? false : getType().contains("*")&& !isArray(); }//$NON-NLS-1$

		public boolean isMethod() { return (getType() == null) ? false : getType().contains("()"); }//$NON-NLS-1$

		// A complex variable is one with children.  However, it must not be a pointer since a pointer has one child

		// according to GDB, but is still a 'simple' variable

		public boolean isComplex() { return (getType() == null) ? false : getNumChildren() > 0 && !isPointer(); }

		public void setGdbName(String n) { gdbName = n; }

		public void setCurrentFormat(String f) { format = f; }

		public void setExpressionData(String fullExpression, String t, int num) {

			fullExp = fullExpression;

			type = t;

			numChildren = num;

		}

		public void setValue(String format, String val) { valueMap.put(format, val); }

		public void resetValues(String valueInCurrentFormat) {

			resetValues();

			setValue(getCurrentFormat(), valueInCurrentFormat); 

		}

		public void resetValues() {

			valueMap.put(IFormattedValues.NATURAL_FORMAT, null);

			valueMap.put(IFormattedValues.BINARY_FORMAT, null);

			valueMap.put(IFormattedValues.HEX_FORMAT, null);

			valueMap.put(IFormattedValues.OCTAL_FORMAT, null);

			valueMap.put(IFormattedValues.DECIMAL_FORMAT, null);

		}

        public void setChildren(ExpressionInfo[] c) { children = c; }

        public void setParent(MIVariableObject p) { 

        	parent = p; 

        	rootToUpdate = (p == null ? (MIRootVariableObject)this : p.getRootToUpdate());

        }

        public void executeWhenNotUpdating(RequestMonitor rm) {

			getRootToUpdate().executeWhenNotUpdating(rm);

		}

		private void lock() {

			locked = true;

		}

		private void unlock() {

			locked = false;

			while (operationsPending.size() > 0) {

				operationsPending.poll().done();

			}

		}

		public boolean isOutOfScope() { return outOfScope; }

		/**

		 * This method updates the variable object.

		 * Updating a variable object is done by updating its root.

		 */

		public void update(final DataRequestMonitor<Boolean> rm) {

			// We check to see if we are already out-of-scope

			// We must do this to avoid the risk of re-creating this object

			// twice, due to race conditions

			if (isOutOfScope()) {

				rm.setData(false);

				rm.done();

			} else if (currentState == STATE_UPDATING) {

				// If we were already updating, we just queue the request monitor

				// until the on-going update finishes.

				updatesPending.add(rm);

			} else {			

				currentState = STATE_UPDATING;

				getRootToUpdate().update(new DataRequestMonitor<Boolean>(fSession.getExecutor(), rm) {

					@Override

					protected void handleCompleted() {

						currentState = STATE_READY;

						if (isSuccess()) {

							outOfScope = getRootToUpdate().isOutOfScope();

							// This request monitor is the one that should re-create

							// the variable object if the old one was out-of-scope							

							rm.setData(outOfScope);

							rm.done();

							// All the other request monitors must be notified but must

							// not re-create the object, even if it is out-of-scope

							while (updatesPending.size() > 0) {

								DataRequestMonitor<Boolean> pendingRm = updatesPending.poll();

								pendingRm.setData(false);

								pendingRm.done();

							}

						} else {

							rm.setStatus(getStatus());

							rm.done();

							while (updatesPending.size() > 0) {

								DataRequestMonitor<Boolean> pendingRm = updatesPending.poll();

								pendingRm.setStatus(getStatus());

								pendingRm.done();

							}							

						}

					}

				});

			}

		}

		/**

		 * Variable objects need not be deleted unless they are root.

		 * This method is specialized in the MIRootVariableObject class.

		 */

		public void deleteInGdb() {}

		/** 

		 * This method returns the value of the variable object attributes by

		 * using -var-show-attributes.

		 * Currently, the only attribute available is 'editable'.

		 *  

		 * @param rm

		 *            The data request monitor that will hold the value returned

		 */

        private void getAttributes(final DataRequestMonitor<Boolean> rm) {

            if (editable != null) { 

                rm.setData(editable);

                rm.done();

            } else if (isComplex()) {

                editable = false;

                rm.setData(editable);

                rm.done();

            } else {

                fCommandControl.queueCommand(

                        new MIVarShowAttributes(getRootToUpdate().getControlDMContext(), getGdbName()), 

                        new DataRequestMonitor<MIVarShowAttributesInfo>(fSession.getExecutor(), rm) {

                            @Override

                            protected void handleSuccess() {

                            	editable = getData().isEditable();

                            	rm.setData(editable);

                            	rm.done();

                            }

                        });

            }

        }

		/** 

		 * This method returns the value of the variable object.

		 * This operation translates to multiple MI commands which affect the state of the

		 * variable object in the back-end; therefore, we must make sure the object is not

		 * locked doing another operation, and we must lock the object once it is our turn

		 * to use it.

		 * 

		 * @param dmc  

		 *            The context containing the format to be used for the evaluation

		 * @param rm

		 *            The data request monitor that will hold the value returned

		 */

		private void getValue(final FormattedValueDMContext dmc,

				              final DataRequestMonitor<FormattedValueDMData> rm) {

			// We might already know the value

			String value = getValue(dmc.getFormatID());

			if (value != null) {

				rm.setData(new FormattedValueDMData(value));

				rm.done();

				return;

			}

			// If the variable is a complex structure, there is no need to ask the back-end for a value,

			// we can give it the {...} ourselves

			// Unless we are dealing with an array, in which case, we want to get the address of it

			if (isComplex()) {

				if (isArray()) {

					// Figure out the address

					IExpressionDMContext exprCxt = DMContexts.getAncestorOfType(dmc, IExpressionDMContext.class);

					IExpressionDMContext addrCxt = fExpressionService.createExpression(exprCxt, "&(" + exprCxt.getExpression() + ")");  //$NON-NLS-1$//$NON-NLS-2$

					final FormattedValueDMContext formatCxt = new FormattedValueDMContext(

							fSession.getId(),

							addrCxt,

							dmc.getFormatID()

					);

					getVariable(

							addrCxt,

							new DataRequestMonitor<MIVariableObject>(fSession.getExecutor(), rm) {

								@Override

								protected void handleSuccess() {

									getData().getValue(formatCxt, rm);

								}

							});

				} else {

					// Other complex structure

					String complexValue = "{...}";     //$NON-NLS-1$

					setValue(dmc.getFormatID(), complexValue);

					rm.setData(new FormattedValueDMData(complexValue));

					rm.done();

				}

				return;

			}

			if (locked) {

				operationsPending.add(new RequestMonitor(fSession.getExecutor(), rm) {

					@Override

					protected void handleSuccess() {

						getValue(dmc, rm);

					}

				});

			} else {

				lock();

				// If the format is already the one set for this variable object,

				// we don't need to set it again

				if (dmc.getFormatID().equals(getCurrentFormat())) {

					evaluate(rm);								

				} else {

					// We must first set the new format and then evaluate the variable

					fCommandControl.queueCommand(

							new MIVarSetFormat(getRootToUpdate().getControlDMContext(), getGdbName(), dmc.getFormatID()), 

							new DataRequestMonitor<MIVarSetFormatInfo>(fSession.getExecutor(), rm) {

								@Override

								protected void handleCompleted() {

									if (isSuccess()) {

										setCurrentFormat(dmc.getFormatID());

										// If set-format returned the value, no need to evaluate

										// This is only valid after GDB 6.7

										if (getData().getValue() != null) {

    										setValue(dmc.getFormatID(), getData().getValue());

											rm.setData(new FormattedValueDMData(getData().getValue()));

											rm.done();

											// Unlock is done within this method

											resetFormatToNatural();

										} else {

										    evaluate(rm);

										}

									} else {

										rm.setStatus(getStatus());

										rm.done();

										unlock();

									}

								}

							});

				}

			}

		}

		/** 

		 * This method evaluates a variable object 

		 */

		private void evaluate(final DataRequestMonitor<FormattedValueDMData> rm) {

			fCommandControl.queueCommand(

					new MIVarEvaluateExpression(getRootToUpdate().getControlDMContext(), getGdbName()), 

					new DataRequestMonitor<MIVarEvaluateExpressionInfo>(fSession.getExecutor(), rm) {

						@Override

						protected void handleCompleted() {

							if (isSuccess()) {

								setValue(getCurrentFormat(), getData().getValue());

								rm.setData(new FormattedValueDMData(getData().getValue()));

								rm.done();

							} else {

								rm.setStatus(getStatus());

								rm.done();

							}

							// Unlock is done within this method

							resetFormatToNatural();

						}

					});

		}

		// In GDB, var-update will only report a change if -var-evaluate-expression has

		// changed -- in the current format--.  This means that situations like

		// double z = 1.2;

		// z = 1.4;

		// Will not report a change if the format is anything else than natural.

		// This is because 1.2 and 1.4 are both printed as 1, 0x1, etc

		// Since we cache the values of every format, we must know if -any- format has

		// changed, not just the current one.

		// To solve this, we always do an update in the natural format; I am not aware

		// of any case where the natural format would stay the same, but another format

		// would change.  However, since a var-update update all children as well,

		// we must make sure these children are also in the natural format

		// The simplest way to do this is that whenever we change the format

		// of a variable object, we immediately set it back to natural with a second

		// var-set-format command.

		private void resetFormatToNatural() {

			if (!getCurrentFormat().equals(IFormattedValues.NATURAL_FORMAT)) {

				fCommandControl.queueCommand(

						new MIVarSetFormat(getRootToUpdate().getControlDMContext(), getGdbName(), IFormattedValues.NATURAL_FORMAT), 

						new DataRequestMonitor<MIVarSetFormatInfo>(fSession.getExecutor(), null) {

							@Override

							protected void handleCompleted() {

								if (isSuccess()) {

									setCurrentFormat(IFormattedValues.NATURAL_FORMAT);

								}

								unlock();

							}

						});

			} else {

				unlock();

			}			

		}

		/** 

		 * This method returns the list of children of the variable object passed as a parameter.

		 * 

		 * @param rm

		 *            The data request monitor that will hold the children returned

		 */

		private void getChildren(final MIExpressionDMC exprDmc, final DataRequestMonitor<ExpressionInfo[]> rm) {

	        // If we already know the children, no need to go to the back-end

			ExpressionInfo[] childrenArray = getChildren();

	        if (childrenArray != null) {

	            rm.setData(childrenArray);

	            rm.done();

	            return;

	        }

			// If the variable does not have children, we can return an empty list right away

			if (getNumChildren() == 0) {

	        	// First store the empty list, for the next time

				setChildren(new ExpressionInfo[0]);

				rm.setData(getChildren());

				rm.done();

				return;

			}

	        // For arrays (which could be very large), we create the children ourselves.  This is

	        // to avoid creating an enormous amount of children variable objects that the view may

	        // never need.  Using -var-list-children will create a variable object for every child

	        // immediately, that is why won't don't want to use it for arrays.

	        if (isArray()) {

	        	ExpressionInfo[] childrenOfArray = new ExpressionInfo[getNumChildren()];

	        	for (int i= 0; i < childrenOfArray.length; i++) {

	        		String indexStr = "[" + i + "]";//$NON-NLS-1$//$NON-NLS-2$