Bug 104421: Register view can not show correct value when switch between different thread or stack frame.

debug/org.eclipse.cdt.debug.core/ChangeLog

@@ -1,3 +1,23 @@
+2005-07-28 Mikhail Khodjaiants
+	Bug 104421: Register view can not show correct value when switch between different thread or stack frame.
+	* ICDIRegister.java
+	* ICDIStackFrame.java
+	* ICDITarget.java
+	* ICDIThread.java
+	* ICDIVariable.java
+	* ICDIVariableDescriptor.java
+	* CRegisterManager.java
+	* CExpression.java
+	* CGlobalVariable.java
+	* CIndexedValue.java
+	+ CLocalVariable.java
+	* CRegister.java
+	* CRegisterGroup.java
+	* CStackFrame.java
+	* CValue.java
+	* CVariable.java
+	* CVariableFactory.java
+
 2005-07-28 Mikhail Khodjaiants
 	Bug 103567: breakpoints view of of sync w/CDT CVS HEAD
 	* CBreakpointManager.java

debug/org.eclipse.cdt.debug.core/cdi/org/eclipse/cdt/debug/core/cdi/model/ICDIRegister.java

@@ -11,6 +11,8 @@
 
 package org.eclipse.cdt.debug.core.cdi.model;
 
+import org.eclipse.cdt.debug.core.cdi.CDIException;
+
 /**
  * 
  * A register is a special kind of variable that is contained
@@ -18,5 +20,50 @@ package org.eclipse.cdt.debug.core.cdi.model;
  * 
  * @since Jul 9, 2002
  */
-public interface ICDIRegister extends ICDIVariable, ICDIRegisterDescriptor {
+public interface ICDIRegister extends ICDIRegisterDescriptor {
+	/**
+	 * Returns true if the value of this variable could be changed.
+	 * 
+	 * @return true if the value of this variable could be changed
+	 * @throws CDIException if this method fails.  Reasons include:
+	 */
+	boolean isEditable() throws CDIException;
+
+	/**
+	 * Returns the value of this variable.
+	 * 
+	 * @param context
+	 * @return the value of this variable
+	 * @throws CDIException if this method fails.  Reasons include:
+	 */
+	ICDIValue getValue(ICDIStackFrame context) throws CDIException;
+
+	/**
+	 * Attempts to set the value of this variable to the value of 
+	 * the given expression.
+	 * 
+	 * @param expression - an expression to generate a new value
+	 * @throws CDIException if this method fails.  Reasons include:
+	 */
+	void setValue(String expression) throws CDIException;
+
+	/**
+	 * Sets the value of this variable to the given value.
+	 * 
+	 * @param value - a new value
+	 * @throws CDIException if this method fails.  Reasons include:
+	 */
+	void setValue(ICDIValue value) throws CDIException;
+	
+	/**
+	 * Remove the variable from the manager list.
+	 * 
+	 * @param var
+	 * @return ICDIArgument
+	 * @throws CDIException
+	 */
+	void dispose() throws CDIException;
+
+	boolean equals(ICDIRegister reg);
+
 }

debug/org.eclipse.cdt.debug.core/cdi/org/eclipse/cdt/debug/core/cdi/model/ICDIStackFrame.java

@@ -40,7 +40,29 @@ public interface ICDIStackFrame extends ICDIExecuteStepReturn, ICDIObject {
 	 * @throws CDIException if this method fails.  Reasons include:
 	 */
 	ICDILocalVariableDescriptor[] getLocalVariableDescriptors() throws CDIException;
-	
+
+	/**
+	 * Create a variable from the descriptor for evaluation.  A CreatedEvent will be trigger and
+	 * ChangedEvent will also be trigger when the variable is assign a new value.
+	 * DestroyedEvent is fired when the variable is out of scope and automatically
+	 * removed from the manager list.
+	 * @param varDesc ICDThreadStorageDesc
+	 * @return
+	 * @throws CDIException
+	 */
+	ICDIArgument createArgument(ICDIArgumentDescriptor varDesc) throws CDIException;
+
+	/**
+	 * Create a variable from the descriptor for evaluation.  A CreatedEvent will be trigger and
+	 * ChangedEvent will also be trigger when the variable is assign a new value.
+	 * DestroyedEvent is fired when the variable is out of scope and automatically
+	 * removed from the manager list.
+	 * @param varDesc ICDThreadStorageDesc
+	 * @return
+	 * @throws CDIException
+	 */
+	ICDILocalVariable createLocalVariable(ICDILocalVariableDescriptor varDesc) throws CDIException;
+
 	/**
 	 * Returns the arguments in this stack frame. An empty collection 
 	 * is returned if there are no arguments.

debug/org.eclipse.cdt.debug.core/cdi/org/eclipse/cdt/debug/core/cdi/model/ICDITarget.java

@@ -77,10 +77,22 @@ public interface ICDITarget extends ICDIThreadGroup, ICDIExpressionManagement,
 	 * @param filename
 	 * @param function
 	 * @param name
-	 * @return ICDIVariableDescriptor
+	 * @return ICDIGlobalVariableDescriptor
 	 * @throws CDIException
 	 */
-	ICDIVariableDescriptor getGlobalVariableDescriptors(String filename, String function, String name) throws CDIException;
+	ICDIGlobalVariableDescriptor getGlobalVariableDescriptors(String filename, String function, String name) throws CDIException;
+
+	/**
+	 * Create a variable from the descriptor for evaluation.  A CreatedEvent will be trigger and
+	 * ChangedEvent will also be trigger when the variable is assign a new value.
+	 * DestroyedEvent is fired when the variable is out of scope and automatically
+	 * removed from the manager list.
+	 * 
+	 * @param varDesc ICDIGlobalVariableDescriptor
+	 * @return ICDIGlobalVariable
+	 * @throws CDIException
+	 */
+	ICDIGlobalVariable createGlobalVariable(ICDIGlobalVariableDescriptor varDesc) throws CDIException;
 
 	/**
 	 * Return the register groups.
@@ -89,6 +101,17 @@ public interface ICDITarget extends ICDIThreadGroup, ICDIExpressionManagement,
 	 */
 	ICDIRegisterGroup[] getRegisterGroups() throws CDIException;
 
+	/**
+	 * Create a variable from the descriptor for evaluation.  A CreatedEvent will be trigger and
+	 * ChangedEvent will also be trigger when the variable is assign a new value.
+	 * DestroyedEvent is fired when the variable is out of scope and automatically
+	 * removed from the manager list.
+	 * @param varDesc ICDThreadStorageDesc
+	 * @return
+	 * @throws CDIException
+	 */
+	ICDIRegister createRegister(ICDIRegisterDescriptor varDesc) throws CDIException;
+
 	/**
 	 * Returns whether this target is terminated.
 	 *

debug/org.eclipse.cdt.debug.core/cdi/org/eclipse/cdt/debug/core/cdi/model/ICDIThread.java

@@ -66,6 +66,17 @@ public interface ICDIThread extends ICDIExecuteStep, ICDIExecuteResume, ICDISusp
 	 */
 	ICDIThreadStorageDescriptor[] getThreadStorageDescriptors() throws CDIException;
 
+	/**
+	 * Create a variable from the descriptor for evaluation.  A CreatedEvent will be trigger and
+	 * ChangedEvent will also be trigger when the variable is assign a new value.
+	 * DestroyedEvent is fired when the variable is out of scope and automatically
+	 * removed from the manager list.
+	 * @param varDesc ICDThreadStorageDesc
+	 * @return
+	 * @throws CDIException
+	 */
+	ICDIThreadStorage createThreadStorage(ICDIThreadStorageDescriptor varDesc) throws CDIException;
+
 	/**
 	 * Equivalent to resume(false)
 	 * 

debug/org.eclipse.cdt.debug.core/cdi/org/eclipse/cdt/debug/core/cdi/model/ICDIVariable.java

@@ -55,14 +55,6 @@ public interface ICDIVariable extends ICDIVariableDescriptor {
 	 */
 	void setValue(ICDIValue value) throws CDIException;
 	
-	/**
-	 * Set the format of the variable.
-	 * 
-	 * @param format - @see ICDIFormat
-	 * @throws CDIException if this method fails.
-	 */
-	void setFormat(int format) throws CDIException;
-
 	/**
 	 * Remove the variable from the manager list.
 	 * 

debug/org.eclipse.cdt.debug.core/cdi/org/eclipse/cdt/debug/core/cdi/model/ICDIVariableDescriptor.java

@@ -78,17 +78,6 @@ public interface ICDIVariableDescriptor extends ICDIObject {
 	 */
 	ICDIVariableDescriptor getVariableDescriptorAsType(String type) throws CDIException;
 
-	/**
-	 * Create a Variable for evaluation.  A CreatedEvent will be trigger and
-	 * ChangedEvent will also be trigger when the variable is assign a new value.
-	 * DestroyedEvent is fired when the variable is out of scope and automatically
-	 * removed from the manager list.
-	 * @param var
-	 * @return ICDIVariable
-	 * @throws CDIException
-	 */
-	ICDIVariable createVariable() throws CDIException;
-
 	/**
 	 * Returns true if the variable Object are the same,
 	 * For example event if the name is the same because of

debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/CRegisterManager.java

@@ -65,6 +65,8 @@ public class CRegisterManager {
 
 	private boolean fUseDefaultRegisterGroups = true;
 
+	private CStackFrame fCurrentFrame;
+
 	/** 
 	 * Constructor for CRegisterManager. 
 	 */
@@ -101,7 +103,14 @@ public class CRegisterManager {
 	}
 
 	public IRegisterGroup[] getRegisterGroups( CStackFrame frame ) throws DebugException {
-		return (IRegisterGroup[])fRegisterGroups.toArray( new IRegisterGroup[fRegisterGroups.size()] );
+		IRegisterGroup[] groups = (IRegisterGroup[])fRegisterGroups.toArray( new IRegisterGroup[fRegisterGroups.size()] );
+		if ( getCurrentFrame() != frame ) {
+			for ( int i = 0; i < groups.length; ++i ) {
+				((CRegisterGroup)groups[i]).resetRegisterValues();
+			}
+			setCurrentFrame( frame );
+		}
+		return groups;
 	}
 
 	public void initialize() {
@@ -328,4 +337,12 @@ public class CRegisterManager {
 	protected void setUseDefaultRegisterGroups( boolean useDefaultRegisterGroups ) {
 		fUseDefaultRegisterGroups = useDefaultRegisterGroups;
 	}
+
+	public CStackFrame getCurrentFrame() {
+		return fCurrentFrame;
+	}
+	
+	private void setCurrentFrame( CStackFrame currentFrame ) {
+		fCurrentFrame = currentFrame;
+	}
 }

debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/model/CExpression.java

@@ -31,7 +31,7 @@ import org.eclipse.debug.core.model.IValue;
 /**
  * Represents an expression in the CDI model.
  */
-public class CExpression extends CVariable implements IExpression {
+public class CExpression extends CLocalVariable implements IExpression {
 
 	private String fText;
 

debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/model/CGlobalVariable.java

@@ -10,19 +10,306 @@
  *******************************************************************************/
 package org.eclipse.cdt.debug.internal.core.model;
 
+import org.eclipse.cdt.debug.core.cdi.CDIException;
 import org.eclipse.cdt.debug.core.cdi.event.ICDIEvent;
 import org.eclipse.cdt.debug.core.cdi.event.ICDIResumedEvent;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIArgumentDescriptor;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIGlobalVariableDescriptor;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIObject;
 import org.eclipse.cdt.debug.core.cdi.model.ICDITarget;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIValue;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIVariable;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIVariableDescriptor;
+import org.eclipse.cdt.debug.core.cdi.model.type.ICDIArrayValue;
+import org.eclipse.cdt.debug.core.cdi.model.type.ICDIType;
 import org.eclipse.cdt.debug.core.model.ICGlobalVariable;
+import org.eclipse.cdt.debug.core.model.ICType;
+import org.eclipse.cdt.debug.core.model.ICValue;
 import org.eclipse.cdt.debug.core.model.IGlobalVariableDescriptor;
+import org.eclipse.debug.core.DebugException;
 
 /**
  * Represents a global variable.
  */
 public class CGlobalVariable extends CVariable implements ICGlobalVariable {
 
+	private class InternalVariable implements IInternalVariable {
+		
+		/**
+		 * The enclosing <code>CVariable</code> instance.
+		 */
+		private CVariable fVariable;
+
+		/**
+		 * The CDI variable object this variable is based on.
+		 */
+		private ICDIVariableDescriptor fCDIVariableObject;
+
+		/**
+		 * The underlying CDI variable.
+		 */
+		private ICDIVariable fCDIVariable;
+
+		/**
+		 * The type of this variable.
+		 */
+		private CType fType;
+
+		/**
+		 * The expression used to eveluate the value of this variable.
+		 */
+		private String fQualifiedName;
+
+		/**
+		 * The cache of the current value.
+		 */
+		private ICValue fValue = CValueFactory.NULL_VALUE;
+
+		/**
+		 * The change flag.
+		 */
+		private boolean fChanged = false;
+
+		/**
+		 * Constructor for InternalVariable.
+		 */
+		InternalVariable( CVariable var, ICDIVariableDescriptor varObject ) {
+			setVariable( var );
+			setCDIVariableObject( varObject );
+			setCDIVariable( (varObject instanceof ICDIVariable) ? (ICDIVariable)varObject : null );
+		}
+
+		public IInternalVariable createShadow( int start, int length ) throws DebugException {
+			IInternalVariable iv = null;
+			try {
+				iv = new InternalVariable( getVariable(), getCDIVariableObject().getVariableDescriptorAsArray( start, length ) );
+			}
+			catch( CDIException e ) {
+				requestFailed( e.getMessage(), null );
+			}
+			return iv;
+		}
+
+		public IInternalVariable createShadow( String type ) throws DebugException {
+			IInternalVariable iv = null;
+			try {
+				iv = new InternalVariable( getVariable(), getCDIVariableObject().getVariableDescriptorAsType( type ) );
+			}
+			catch( CDIException e ) {
+				requestFailed( e.getMessage(), null );
+			}
+			return iv;
+		}
+
+		private synchronized ICDIVariable getCDIVariable() throws DebugException {
+			if ( fCDIVariable == null ) {
+				try {
+					fCDIVariable = getCDITarget().createGlobalVariable( (ICDIGlobalVariableDescriptor)getCDIVariableObject() );
+				}
+				catch( CDIException e ) {
+					requestFailed( e.getMessage(), null );
+				}
+			}
+			return fCDIVariable;
+		}
+
+		private void setCDIVariable( ICDIVariable variable ) {
+			fCDIVariable = variable;
+		}
+
+		private ICDIVariableDescriptor getCDIVariableObject() {
+			if ( fCDIVariable != null ) {
+				return fCDIVariable;
+			}
+			return fCDIVariableObject;
+		}
+
+		private void setCDIVariableObject( ICDIVariableDescriptor variableObject ) {
+			fCDIVariableObject = variableObject;
+		}
+
+		public String getQualifiedName() throws DebugException {
+			if ( fQualifiedName == null ) {
+				try {
+					fQualifiedName = (fCDIVariableObject != null) ? fCDIVariableObject.getQualifiedName() : null;
+				}
+				catch( CDIException e ) {
+					requestFailed( e.getMessage(), null );
+				}
+			}
+			return fQualifiedName;
+		}
+
+		public CType getType() throws DebugException {
+			if ( fType == null ) {
+				ICDIVariableDescriptor varObject = getCDIVariableObject();
+				if ( varObject != null ) {
+					synchronized( this ) {
+						if ( fType == null ) {
+							try {
+								fType = new CType( varObject.getType() );
+							}
+							catch( CDIException e ) {
+								requestFailed( e.getMessage(), null );
+							}
+						}
+					}
+				}
+			}
+			return fType;
+		}
+
+		private synchronized void invalidate( boolean destroy ) {
+			try {
+				if ( destroy && fCDIVariable != null )
+					fCDIVariable.dispose();
+			}
+			catch( CDIException e ) {
+				logError( e.getMessage() );
+			}
+			invalidateValue();
+			setCDIVariable( null );
+			if ( fType != null )
+				fType.dispose();
+			fType = null;
+		}
+
+		public void dispose( boolean destroy ) {
+			invalidate( destroy );
+		}
+
+		public boolean isSameVariable( ICDIVariable cdiVar ) {
+			return ( fCDIVariable != null ) ? fCDIVariable.equals( cdiVar ) : false;
+		}
+
+		public int sizeof() {
+			if ( getCDIVariableObject() != null ) {
+				try {
+					return getCDIVariableObject().sizeof();
+				}
+				catch( CDIException e ) {
+				}
+			}
+			return 0;
+		}
+
+		public boolean isArgument() {
+			return ( getCDIVariableObject() instanceof ICDIArgumentDescriptor );
+		}
+
+		public void setValue( String expression ) throws DebugException {
+			ICDIVariable cdiVariable = null;
+			try {
+				cdiVariable = getCDIVariable();
+				if ( cdiVariable != null )
+					cdiVariable.setValue( expression );
+				else
+					requestFailed( CoreModelMessages.getString( "CModificationVariable.0" ), null ); //$NON-NLS-1$
+			}
+			catch( CDIException e ) {
+				targetRequestFailed( e.getMessage(), null );
+			}
+		}
+
+		public synchronized ICValue getValue() throws DebugException {
+			if ( fValue.equals( CValueFactory.NULL_VALUE ) ) {
+				ICDIVariable var = getCDIVariable();
+				if ( var != null ) {
+					try {
+						ICDIValue cdiValue = var.getValue();
+						if ( cdiValue != null ) {
+							ICDIType cdiType = cdiValue.getType();
+							if ( cdiValue instanceof ICDIArrayValue && cdiType != null ) {
+								ICType type = new CType( cdiType );
+								if ( type.isArray() ) {
+									int[] dims = type.getArrayDimensions();
+									if ( dims.length > 0 && dims[0] > 0 )
+										fValue = CValueFactory.createIndexedValue( getVariable(), (ICDIArrayValue)cdiValue, 0, dims[0] );
+								}
+							}
+							else {
+								fValue = CValueFactory.createValue( getVariable(), cdiValue );
+							}
+						}
+					}
+					catch( CDIException e ) {
+						requestFailed( e.getMessage(), e );
+					}
+				}
+			}
+			return fValue;
+		}
+		
+		public void invalidateValue() {
+			if ( fValue instanceof AbstractCValue ) {
+				((AbstractCValue)fValue).dispose();
+				fValue = CValueFactory.NULL_VALUE;
+			}
+		}
+
+		public boolean isChanged() {
+			return fChanged;
+		}
+
+		public synchronized void setChanged( boolean changed ) {
+			if ( changed ) {
+				invalidateValue();
+			}
+			if ( fValue instanceof AbstractCValue ) {
+				((AbstractCValue)fValue).setChanged( changed );
+			}
+			fChanged = changed;
+		}
+
+		public synchronized void preserve() {
+			setChanged( false );
+			if ( fValue instanceof AbstractCValue ) {
+				((AbstractCValue)fValue).preserve();
+			}
+		}
+
+		CVariable getVariable() {
+			return fVariable;
+		}
+
+		private void setVariable( CVariable variable ) {
+			fVariable = variable;
+		}
+
+		public void resetValue() {
+			if ( fValue instanceof AbstractCValue ) {
+				((AbstractCValue)fValue).reset();
+			}
+		}
+
+		public boolean isEditable() throws DebugException {
+			ICDIVariable var = getCDIVariable();
+			if ( var != null ) {
+				try {
+					return var.isEditable();
+				}
+				catch( CDIException e ) {
+				}
+			}
+			return false;
+		}
+
+		/**
+		 * Compares the underlying variable objects.
+		 * @see java.lang.Object#equals(java.lang.Object)
+		 */
+		public boolean equals( Object obj ) {
+			if ( obj instanceof InternalVariable ) {
+				return getCDIVariableObject().equals( ((InternalVariable)obj).getCDIVariableObject() );
+			}
+			return false;
+		}
+
+		public boolean isSameDescriptor( ICDIVariableDescriptor desc ) {
+			return getCDIVariableObject().equals( desc );
+		}
+	}
+
 	private IGlobalVariableDescriptor fDescriptor;
 
 	/**
@@ -81,4 +368,11 @@ public class CGlobalVariable extends CVariable implements ICGlobalVariable {
 		internalDispose( true );
 		setDisposed( true );
 	}
+
+	protected void createOriginal( ICDIVariableDescriptor vo ) {
+		if ( vo != null ) {
+			setName( vo.getName() );
+			setOriginal( new InternalVariable( this, vo ) );
+		}
+	}
 }

debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/model/CIndexedValue.java

@@ -250,7 +250,7 @@ public class CIndexedValue extends AbstractCValue implements IIndexedValue {
 			requestFailed( e.getMessage(), null );
 		}
 		for( int i = 0; i < cdiVars.length; ++i )
-			fVariables[i + index * prefSize] = CVariableFactory.createVariable( getParentVariable(), cdiVars[i] );
+			fVariables[i + index * prefSize] = CVariableFactory.createLocalVariable( getParentVariable(), cdiVars[i] );
 	}
 
 	private int getSize0() {

debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/model/CLocalVariable.java

@@ -0,0 +1,325 @@
+/**********************************************************************
+ * Copyright (c) 2004 QNX Software Systems and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * QNX Software Systems - Initial API and implementation
+ ***********************************************************************/ 
+package org.eclipse.cdt.debug.internal.core.model; 
+
+import org.eclipse.cdt.debug.core.cdi.CDIException;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIArgumentDescriptor;
+import org.eclipse.cdt.debug.core.cdi.model.ICDILocalVariableDescriptor;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIValue;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIVariable;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIVariableDescriptor;
+import org.eclipse.cdt.debug.core.cdi.model.type.ICDIArrayValue;
+import org.eclipse.cdt.debug.core.cdi.model.type.ICDIType;
+import org.eclipse.cdt.debug.core.model.ICType;
+import org.eclipse.cdt.debug.core.model.ICValue;
+import org.eclipse.debug.core.DebugException;
+ 
+
+public class CLocalVariable extends CVariable {
+
+	private class InternalVariable implements IInternalVariable {
+		
+		/**
+		 * The enclosing <code>CVariable</code> instance.
+		 */
+		private CVariable fVariable;
+
+		/**
+		 * The CDI variable object this variable is based on.
+		 */
+		private ICDIVariableDescriptor fCDIVariableObject;
+
+		/**
+		 * The underlying CDI variable.
+		 */
+		private ICDIVariable fCDIVariable;
+
+		/**
+		 * The type of this variable.
+		 */
+		private CType fType;
+
+		/**
+		 * The expression used to eveluate the value of this variable.
+		 */
+		private String fQualifiedName;
+
+		/**
+		 * The cache of the current value.
+		 */
+		private ICValue fValue = CValueFactory.NULL_VALUE;
+
+		/**
+		 * The change flag.
+		 */
+		private boolean fChanged = false;
+
+		/**
+		 * Constructor for InternalVariable.
+		 */
+		InternalVariable( CVariable var, ICDIVariableDescriptor varObject ) {
+			setVariable( var );
+			setCDIVariableObject( varObject );
+			setCDIVariable( (varObject instanceof ICDIVariable) ? (ICDIVariable)varObject : null );
+		}
+
+		public IInternalVariable createShadow( int start, int length ) throws DebugException {
+			IInternalVariable iv = null;
+			try {
+				iv = new InternalVariable( getVariable(), getCDIVariableObject().getVariableDescriptorAsArray( start, length ) );
+			}
+			catch( CDIException e ) {
+				requestFailed( e.getMessage(), null );
+			}
+			return iv;
+		}
+
+		public IInternalVariable createShadow( String type ) throws DebugException {
+			IInternalVariable iv = null;
+			try {
+				iv = new InternalVariable( getVariable(), getCDIVariableObject().getVariableDescriptorAsType( type ) );
+			}
+			catch( CDIException e ) {
+				requestFailed( e.getMessage(), null );
+			}
+			return iv;
+		}
+
+		private synchronized ICDIVariable getCDIVariable() throws DebugException {
+			if ( fCDIVariable == null ) {
+				try {
+					fCDIVariable = ((CStackFrame)getStackFrame()).getCDIStackFrame().createLocalVariable( (ICDILocalVariableDescriptor)getCDIVariableObject() );
+				}
+				catch( CDIException e ) {
+					requestFailed( e.getMessage(), null );
+				}
+			}
+			return fCDIVariable;
+		}
+
+		private void setCDIVariable( ICDIVariable variable ) {
+			fCDIVariable = variable;
+		}
+
+		private ICDIVariableDescriptor getCDIVariableObject() {
+			if ( fCDIVariable != null ) {
+				return fCDIVariable;
+			}
+			return fCDIVariableObject;
+		}
+
+		private void setCDIVariableObject( ICDIVariableDescriptor variableObject ) {
+			fCDIVariableObject = variableObject;
+		}
+
+		public String getQualifiedName() throws DebugException {
+			if ( fQualifiedName == null ) {
+				try {
+					fQualifiedName = (fCDIVariableObject != null) ? fCDIVariableObject.getQualifiedName() : null;
+				}
+				catch( CDIException e ) {
+					requestFailed( e.getMessage(), null );
+				}
+			}
+			return fQualifiedName;
+		}
+
+		public CType getType() throws DebugException {
+			if ( fType == null ) {
+				ICDIVariableDescriptor varObject = getCDIVariableObject();
+				if ( varObject != null ) {
+					synchronized( this ) {
+						if ( fType == null ) {
+							try {
+								fType = new CType( varObject.getType() );
+							}
+							catch( CDIException e ) {
+								requestFailed( e.getMessage(), null );
+							}
+						}
+					}
+				}
+			}
+			return fType;
+		}
+
+		private synchronized void invalidate( boolean destroy ) {
+			try {
+				if ( destroy && fCDIVariable != null )
+					fCDIVariable.dispose();
+			}
+			catch( CDIException e ) {
+				logError( e.getMessage() );
+			}
+			invalidateValue();
+			setCDIVariable( null );
+			if ( fType != null )
+				fType.dispose();
+			fType = null;
+		}
+
+		public void dispose( boolean destroy ) {
+			invalidate( destroy );
+		}
+
+		public boolean isSameVariable( ICDIVariable cdiVar ) {
+			return ( fCDIVariable != null ) ? fCDIVariable.equals( cdiVar ) : false;
+		}
+
+		public int sizeof() {
+			if ( getCDIVariableObject() != null ) {
+				try {
+					return getCDIVariableObject().sizeof();
+				}
+				catch( CDIException e ) {
+				}
+			}
+			return 0;
+		}
+
+		public boolean isArgument() {
+			return ( getCDIVariableObject() instanceof ICDIArgumentDescriptor );
+		}
+
+		public void setValue( String expression ) throws DebugException {
+			ICDIVariable cdiVariable = null;
+			try {
+				cdiVariable = getCDIVariable();
+				if ( cdiVariable != null )
+					cdiVariable.setValue( expression );
+				else
+					requestFailed( CoreModelMessages.getString( "CModificationVariable.0" ), null ); //$NON-NLS-1$
+			}
+			catch( CDIException e ) {
+				targetRequestFailed( e.getMessage(), null );
+			}
+		}
+
+		public synchronized ICValue getValue() throws DebugException {
+			if ( fValue.equals( CValueFactory.NULL_VALUE ) ) {
+				ICDIVariable var = getCDIVariable();
+				if ( var != null ) {
+					try {
+						ICDIValue cdiValue = var.getValue();
+						if ( cdiValue != null ) {
+							ICDIType cdiType = cdiValue.getType();
+							if ( cdiValue instanceof ICDIArrayValue && cdiType != null ) {
+								ICType type = new CType( cdiType );
+								if ( type.isArray() ) {
+									int[] dims = type.getArrayDimensions();
+									if ( dims.length > 0 && dims[0] > 0 )
+										fValue = CValueFactory.createIndexedValue( getVariable(), (ICDIArrayValue)cdiValue, 0, dims[0] );
+								}
+							}
+							else {
+								fValue = CValueFactory.createValue( getVariable(), cdiValue );
+							}
+						}
+					}
+					catch( CDIException e ) {
+						requestFailed( e.getMessage(), e );
+					}
+				}
+			}
+			return fValue;
+		}
+		
+		public void invalidateValue() {
+			if ( fValue instanceof AbstractCValue ) {
+				((AbstractCValue)fValue).dispose();
+				fValue = CValueFactory.NULL_VALUE;
+			}
+		}
+
+		public boolean isChanged() {
+			return fChanged;
+		}
+
+		public synchronized void setChanged( boolean changed ) {
+			if ( changed ) {
+				invalidateValue();
+			}
+			if ( fValue instanceof AbstractCValue ) {
+				((AbstractCValue)fValue).setChanged( changed );
+			}
+			fChanged = changed;
+		}
+
+		public synchronized void preserve() {
+			setChanged( false );
+			if ( fValue instanceof AbstractCValue ) {
+				((AbstractCValue)fValue).preserve();
+			}
+		}
+
+		CVariable getVariable() {
+			return fVariable;
+		}
+
+		private void setVariable( CVariable variable ) {
+			fVariable = variable;
+		}
+
+		public void resetValue() {
+			if ( fValue instanceof AbstractCValue ) {
+				((AbstractCValue)fValue).reset();
+			}
+		}
+
+		public boolean isEditable() throws DebugException {
+			ICDIVariable var = getCDIVariable();
+			if ( var != null ) {
+				try {
+					return var.isEditable();
+				}
+				catch( CDIException e ) {
+				}
+			}
+			return false;
+		}
+
+		/**
+		 * Compares the underlying variable objects.
+		 * @see java.lang.Object#equals(java.lang.Object)
+		 */
+		public boolean equals( Object obj ) {
+			if ( obj instanceof InternalVariable ) {
+				return getCDIVariableObject().equals( ((InternalVariable)obj).getCDIVariableObject() );
+			}
+			return false;
+		}
+
+		public boolean isSameDescriptor( ICDIVariableDescriptor desc ) {
+			return getCDIVariableObject().equals( desc );
+		}
+	}
+
+	/** 
+	 * Constructor for CLocalVariable. 
+	 */
+	public CLocalVariable( CDebugElement parent, ICDIVariableDescriptor cdiVariableObject, String errorMessage ) {
+		super( parent, cdiVariableObject, errorMessage );
+	}
+
+	/** 
+	 * Constructor for CLocalVariable. 
+	 */
+	public CLocalVariable( CDebugElement parent, ICDIVariableDescriptor cdiVariableObject ) {
+		super( parent, cdiVariableObject );
+	}
+
+	protected void createOriginal( ICDIVariableDescriptor vo ) {
+		if ( vo != null ) {
+			setName( vo.getName() );
+			setOriginal( new InternalVariable( this, vo ) );
+		}
+	}
+}

debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/model/CRegister.java

@@ -13,7 +13,22 @@ package org.eclipse.cdt.debug.internal.core.model;
 import org.eclipse.cdt.debug.core.CDebugCorePlugin;
 import org.eclipse.cdt.debug.core.ICDTLaunchConfigurationConstants;
 import org.eclipse.cdt.debug.core.ICDebugConstants;
+import org.eclipse.cdt.debug.core.cdi.CDIException;
+import org.eclipse.cdt.debug.core.cdi.event.ICDIEvent;
+import org.eclipse.cdt.debug.core.cdi.event.ICDIResumedEvent;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIArgumentDescriptor;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIObject;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIRegister;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIRegisterDescriptor;
+import org.eclipse.cdt.debug.core.cdi.model.ICDITarget;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIValue;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIVariable;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIVariableDescriptor;
+import org.eclipse.cdt.debug.core.cdi.model.type.ICDIArrayValue;
+import org.eclipse.cdt.debug.core.cdi.model.type.ICDIType;
 import org.eclipse.cdt.debug.core.model.CVariableFormat;
+import org.eclipse.cdt.debug.core.model.ICType;
+import org.eclipse.cdt.debug.core.model.ICValue;
 import org.eclipse.cdt.debug.core.model.IRegisterDescriptor;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.debug.core.DebugException;
@@ -23,13 +38,289 @@ import org.eclipse.debug.core.model.IRegisterGroup;
 /**
  * Represents a register in the CDI model.
  */
-public class CRegister extends CGlobalVariable implements IRegister {
+public class CRegister extends CVariable implements IRegister {
+
+	private class InternalVariable implements IInternalVariable {
+		
+		/**
+		 * The enclosing <code>CVariable</code> instance.
+		 */
+		private CVariable fVariable;
+
+		/**
+		 * The CDI variable object this variable is based on.
+		 */
+		private ICDIVariableDescriptor fCDIVariableObject;
+
+		/**
+		 * The underlying CDI register.
+		 */
+		private ICDIRegister fCDIRegister;
+
+		/**
+		 * The type of this variable.
+		 */
+		private CType fType;
+
+		/**
+		 * The expression used to eveluate the value of this variable.
+		 */
+		private String fQualifiedName;
+
+		/**
+		 * The cache of the current value.
+		 */
+		private ICValue fValue = CValueFactory.NULL_VALUE;
+
+		/**
+		 * The change flag.
+		 */
+		private boolean fChanged = false;
+
+		/**
+		 * Constructor for InternalVariable.
+		 */
+		InternalVariable( CVariable var, ICDIVariableDescriptor varObject ) {
+			setVariable( var );
+			setCDIVariableObject( varObject );
+			setCDIRegister( (varObject instanceof ICDIRegister) ? (ICDIRegister)varObject : null );
+		}
+
+		public IInternalVariable createShadow( int start, int length ) throws DebugException {
+			IInternalVariable iv = null;
+			try {
+				iv = new InternalVariable( getVariable(), getCDIVariableObject().getVariableDescriptorAsArray( start, length ) );
+			}
+			catch( CDIException e ) {
+				requestFailed( e.getMessage(), null );
+			}
+			return iv;
+		}
+
+		public IInternalVariable createShadow( String type ) throws DebugException {
+			IInternalVariable iv = null;
+			try {
+				iv = new InternalVariable( getVariable(), getCDIVariableObject().getVariableDescriptorAsType( type ) );
+			}
+			catch( CDIException e ) {
+				requestFailed( e.getMessage(), null );
+			}
+			return iv;
+		}
+
+		private synchronized ICDIRegister getCDIRegister() throws DebugException {
+			if ( fCDIRegister == null ) {
+				try {
+					fCDIRegister = getCDITarget().createRegister( (ICDIRegisterDescriptor)getCDIVariableObject() );
+				}
+				catch( CDIException e ) {
+					requestFailed( e.getMessage(), null );
+				}
+			}
+			return fCDIRegister;
+		}
+
+		private void setCDIRegister( ICDIRegister register ) {
+			fCDIRegister = register;
+		}
+
+		private ICDIVariableDescriptor getCDIVariableObject() {
+			if ( fCDIRegister != null ) {
+				return fCDIRegister;
+			}
+			return fCDIVariableObject;
+		}
+
+		private void setCDIVariableObject( ICDIVariableDescriptor variableObject ) {
+			fCDIVariableObject = variableObject;
+		}
+
+		public String getQualifiedName() throws DebugException {
+			if ( fQualifiedName == null ) {
+				try {
+					fQualifiedName = (fCDIVariableObject != null) ? fCDIVariableObject.getQualifiedName() : null;
+				}
+				catch( CDIException e ) {
+					requestFailed( e.getMessage(), null );
+				}
+			}
+			return fQualifiedName;
+		}
+
+		public CType getType() throws DebugException {
+			if ( fType == null ) {
+				ICDIVariableDescriptor varObject = getCDIVariableObject();
+				if ( varObject != null ) {
+					synchronized( this ) {
+						if ( fType == null ) {
+							try {
+								fType = new CType( varObject.getType() );
+							}
+							catch( CDIException e ) {
+								requestFailed( e.getMessage(), null );
+							}
+						}
+					}
+				}
+			}
+			return fType;
+		}
+
+		private synchronized void invalidate( boolean destroy ) {
+			try {
+				if ( destroy && fCDIRegister != null )
+					fCDIRegister.dispose();
+			}
+			catch( CDIException e ) {
+				logError( e.getMessage() );
+			}
+			invalidateValue();
+			setCDIRegister( null );
+			if ( fType != null )
+				fType.dispose();
+			fType = null;
+		}
+
+		public void dispose( boolean destroy ) {
+			invalidate( destroy );
+		}
+
+		public boolean isSameVariable( ICDIVariable cdiVar ) {
+			return ( fCDIRegister != null ) ? fCDIRegister.equals( cdiVar ) : false;
+		}
+
+		public int sizeof() {
+			if ( getCDIVariableObject() != null ) {
+				try {
+					return getCDIVariableObject().sizeof();
+				}
+				catch( CDIException e ) {
+				}
+			}
+			return 0;
+		}
+
+		public boolean isArgument() {
+			return ( getCDIVariableObject() instanceof ICDIArgumentDescriptor );
+		}
+
+		public void setValue( String expression ) throws DebugException {
+			ICDIRegister cdiRegister = null;
+			try {
+				cdiRegister = getCDIRegister();
+				if ( cdiRegister != null )
+					cdiRegister.setValue( expression );
+				else
+					requestFailed( CoreModelMessages.getString( "CModificationVariable.0" ), null ); //$NON-NLS-1$
+			}
+			catch( CDIException e ) {
+				targetRequestFailed( e.getMessage(), null );
+			}
+		}
+
+		public synchronized ICValue getValue() throws DebugException {
+			if ( fValue.equals( CValueFactory.NULL_VALUE ) ) {
+				ICDIRegister reg = getCDIRegister();
+				if ( reg != null ) {
+					try {
+						ICDIValue cdiValue = reg.getValue( getCurrentStackFrame().getCDIStackFrame() );
+						if ( cdiValue != null ) {
+							ICDIType cdiType = cdiValue.getType();
+							if ( cdiValue instanceof ICDIArrayValue && cdiType != null ) {
+								ICType type = new CType( cdiType );
+								if ( type.isArray() ) {
+									int[] dims = type.getArrayDimensions();
+									if ( dims.length > 0 && dims[0] > 0 )
+										fValue = CValueFactory.createIndexedValue( getVariable(), (ICDIArrayValue)cdiValue, 0, dims[0] );
+								}
+							}
+							else {
+								fValue = CValueFactory.createValue( getVariable(), cdiValue );
+							}
+						}
+					}
+					catch( CDIException e ) {
+						requestFailed( e.getMessage(), e );
+					}
+				}
+			}
+			return fValue;
+		}
+		
+		public void invalidateValue() {
+			if ( fValue instanceof AbstractCValue ) {
+				((AbstractCValue)fValue).dispose();
+				fValue = CValueFactory.NULL_VALUE;
+			}
+		}
+
+		public boolean isChanged() {
+			return fChanged;
+		}
+
+		public synchronized void setChanged( boolean changed ) {
+			if ( changed ) {
+				invalidateValue();
+			}
+			if ( fValue instanceof AbstractCValue ) {
+				((AbstractCValue)fValue).setChanged( changed );
+			}
+			fChanged = changed;
+		}
+
+		public synchronized void preserve() {
+			setChanged( false );
+			if ( fValue instanceof AbstractCValue ) {
+				((AbstractCValue)fValue).preserve();
+			}
+		}
+
+		CVariable getVariable() {
+			return fVariable;
+		}
+
+		private void setVariable( CVariable variable ) {
+			fVariable = variable;
+		}
+
+		public void resetValue() {
+			if ( fValue instanceof AbstractCValue ) {
+				((AbstractCValue)fValue).reset();
+			}
+		}
+
+		public boolean isEditable() throws DebugException {
+			ICDIRegister reg = getCDIRegister();
+			if ( reg != null ) {
+				try {
+					return reg.isEditable();
+				}
+				catch( CDIException e ) {
+				}
+			}
+			return false;
+		}
+		/**
+		 * Compares the underlying variable objects.
+		 * @see java.lang.Object#equals(java.lang.Object)
+		 */
+		public boolean equals( Object obj ) {
+			if ( obj instanceof InternalVariable ) {
+				return getCDIVariableObject().equals( ((InternalVariable)obj).getCDIVariableObject() );
+			}
+			return false;
+		}
+
+		public boolean isSameDescriptor( ICDIVariableDescriptor desc ) {
+			return getCDIVariableObject().equals( desc );
+		}
+	}
 
 	/**
 	 * Constructor for CRegister.
 	 */
 	protected CRegister( CRegisterGroup parent, IRegisterDescriptor descriptor ) {
-		super( parent, null, ((CRegisterDescriptor)descriptor).getCDIDescriptor() );
+		super( parent, ((CRegisterDescriptor)descriptor).getCDIDescriptor() );
 		setFormat( CVariableFormat.getFormat( CDebugCorePlugin.getDefault().getPluginPreferences().getInt( ICDebugConstants.PREF_DEFAULT_REGISTER_FORMAT ) ) );
 	}
 
@@ -37,7 +328,7 @@ public class CRegister extends CGlobalVariable implements IRegister {
 	 * Constructor for CRegister.
 	 */
 	protected CRegister( CRegisterGroup parent, IRegisterDescriptor descriptor, String message ) {
-		super( parent, null, ((CRegisterDescriptor)descriptor).getCDIDescriptor(), message );
+		super( parent, ((CRegisterDescriptor)descriptor).getCDIDescriptor(), message );
 		setFormat( CVariableFormat.getFormat( CDebugCorePlugin.getDefault().getPluginPreferences().getInt( ICDebugConstants.PREF_DEFAULT_REGISTER_FORMAT ) ) );
 	}
 
@@ -60,4 +351,49 @@ public class CRegister extends CGlobalVariable implements IRegister {
 		}
 		return result;
 	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.cdt.debug.core.model.ICVariable#canEnableDisable()
+	 */
+	public boolean canEnableDisable() {
+		return true;
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.cdt.debug.core.cdi.event.ICDIEventListener#handleDebugEvents(org.eclipse.cdt.debug.core.cdi.event.ICDIEvent[])
+	 */
+	public void handleDebugEvents( ICDIEvent[] events ) {
+		for( int i = 0; i < events.length; i++ ) {
+			ICDIEvent event = events[i];
+			if ( event instanceof ICDIResumedEvent ) {
+				ICDIObject source = event.getSource();
+				if ( source != null ) {
+					ICDITarget cdiTarget = source.getTarget();
+					if (  getCDITarget().equals( cdiTarget ) ) {
+						setChanged( false );
+					}
+				}
+			}
+		}
+		super.handleDebugEvents( events );
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.cdt.debug.internal.core.model.AbstractCVariable#dispose()
+	 */
+	public void dispose() {
+		internalDispose( true );
+		setDisposed( true );
+	}
+
+	protected CStackFrame getCurrentStackFrame() {
+		return ((CDebugTarget)getDebugTarget()).getRegisterManager().getCurrentFrame();
+	}
+
+	protected void createOriginal( ICDIVariableDescriptor vo ) {
+		if ( vo != null ) {
+			setName( vo.getName() );
+			setOriginal( new InternalVariable( this, vo ) );
+		}
+	}
 }

debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/model/CRegisterGroup.java

@@ -241,7 +241,7 @@ public class CRegisterGroup extends CDebugElement implements IPersistableRegiste
 	}
 
 	private void invalidate() {
-		if (fRegisters == null) {
+		if ( fRegisters == null ) {
 			return;
 		}
 		for ( int i = 0; i < fRegisters.length; ++i ) {
@@ -251,4 +251,15 @@ public class CRegisterGroup extends CDebugElement implements IPersistableRegiste
 		}
 		fRegisters = null;
 	}
+
+	public void resetRegisterValues() {
+		if ( fRegisters == null ) {
+			return;
+		}
+		for ( int i = 0; i < fRegisters.length; ++i ) {
+			if ( fRegisters[i] != null ) {
+				((CRegister)fRegisters[i]).invalidateValue();
+			}
+		}
+	}
 }

debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/model/CStackFrame.java

@@ -127,7 +127,7 @@ public class CStackFrame extends CDebugElement implements ICStackFrame, IRestart
 				fVariables = new ArrayList( vars.size() );
 				Iterator it = vars.iterator();
 				while( it.hasNext() ) {
-					fVariables.add( CVariableFactory.createVariable( this, (ICDIVariableDescriptor)it.next() ) );
+					fVariables.add( CVariableFactory.createLocalVariable( this, (ICDIVariableDescriptor)it.next() ) );
 				}
 			}
 			else if ( refreshVariables() ) {
@@ -158,7 +158,7 @@ public class CStackFrame extends CDebugElement implements ICStackFrame, IRestart
 		// add any new locals
 		Iterator newOnes = locals.iterator();
 		while( newOnes.hasNext() ) {
-			fVariables.add( CVariableFactory.createVariable( this, (ICDIVariableDescriptor)newOnes.next() ) );
+			fVariables.add( CVariableFactory.createLocalVariable( this, (ICDIVariableDescriptor)newOnes.next() ) );
 		}
 	}
 

debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/model/CValue.java

@@ -126,7 +126,7 @@ public class CValue extends AbstractCValue {
 				fVariables = new ArrayList( vars.size() );
 				Iterator it = vars.iterator();
 				while( it.hasNext() ) {
-					fVariables.add( CVariableFactory.createVariable( this, (ICDIVariable)it.next() ) );
+					fVariables.add( CVariableFactory.createLocalVariable( this, (ICDIVariable)it.next() ) );
 				}
 				resetStatus();
 			}

debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/model/CVariable.java

@@ -14,19 +14,14 @@ import java.text.MessageFormat;
 import org.eclipse.cdt.debug.core.CDebugCorePlugin;
 import org.eclipse.cdt.debug.core.ICDTLaunchConfigurationConstants;
 import org.eclipse.cdt.debug.core.ICDebugConstants;
-import org.eclipse.cdt.debug.core.cdi.CDIException;
 import org.eclipse.cdt.debug.core.cdi.event.ICDIChangedEvent;
 import org.eclipse.cdt.debug.core.cdi.event.ICDIEvent;
 import org.eclipse.cdt.debug.core.cdi.event.ICDIEventListener;
 import org.eclipse.cdt.debug.core.cdi.event.ICDIResumedEvent;
-import org.eclipse.cdt.debug.core.cdi.model.ICDIArgumentDescriptor;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIObject;
 import org.eclipse.cdt.debug.core.cdi.model.ICDITarget;
-import org.eclipse.cdt.debug.core.cdi.model.ICDIValue;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIVariable;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIVariableDescriptor;
-import org.eclipse.cdt.debug.core.cdi.model.type.ICDIArrayValue;
-import org.eclipse.cdt.debug.core.cdi.model.type.ICDIType;
 import org.eclipse.cdt.debug.core.model.CVariableFormat;
 import org.eclipse.cdt.debug.core.model.ICDebugElementStatus;
 import org.eclipse.cdt.debug.core.model.ICType;
@@ -39,289 +34,26 @@ import org.eclipse.debug.core.model.IValue;
 /**
  * Represents a variable in the CDI model.
  */
-public class CVariable extends AbstractCVariable implements ICDIEventListener {
+public abstract class CVariable extends AbstractCVariable implements ICDIEventListener {
 
-	/**
+	interface IInternalVariable {
-	 * Represents a single CDI variable.
+		IInternalVariable createShadow( int start, int length ) throws DebugException;
-	 */
+		IInternalVariable createShadow( String type ) throws DebugException;
-	private class InternalVariable {
+		CType getType() throws DebugException;
-		
+		String getQualifiedName() throws DebugException;
-		/**
+		ICValue getValue() throws DebugException;
-		 * The enclosing <code>CVariable</code> instance.
+		void setValue( String expression ) throws DebugException;
-		 */
+		boolean isChanged();
-		private CVariable fVariable;
+		void setChanged( boolean changed );
-
+		void dispose( boolean destroy );
-		/**
+		boolean isSameDescriptor( ICDIVariableDescriptor desc );
-		 * The CDI variable object this variable is based on.
+		boolean isSameVariable( ICDIVariable cdiVar );
-		 */
+		void resetValue();
-		private ICDIVariableDescriptor fCDIVariableObject;
+		boolean isEditable() throws DebugException;
-
+		boolean isArgument();
-		/**
+		int sizeof();
-		 * The underlying CDI variable.
+		void invalidateValue();
-		 */
+		void preserve();
-		private ICDIVariable fCDIVariable;
-
-		/**
-		 * The type of this variable.
-		 */
-		private CType fType;
-
-		/**
-		 * The expression used to eveluate the value of this variable.
-		 */
-		private String fQualifiedName;
-
-		/**
-		 * The cache of the current value.
-		 */
-		private ICValue fValue = CValueFactory.NULL_VALUE;
-
-		/**
-		 * The change flag.
-		 */
-		private boolean fChanged = false;
-
-		/**
-		 * Constructor for InternalVariable.
-		 */
-		InternalVariable( CVariable var, ICDIVariableDescriptor varObject ) {
-			setVariable( var );
-			setCDIVariableObject( varObject );
-			setCDIVariable( (varObject instanceof ICDIVariable) ? (ICDIVariable)varObject : null );
-		}
-
-		InternalVariable createShadow( int start, int length ) throws DebugException {
-			InternalVariable iv = null;
-			try {
-				iv = new InternalVariable( getVariable(), getCDIVariableObject().getVariableDescriptorAsArray( start, length ) );
-			}
-			catch( CDIException e ) {
-				requestFailed( e.getMessage(), null );
-			}
-			return iv;
-		}
-
-		InternalVariable createShadow( String type ) throws DebugException {
-			InternalVariable iv = null;
-			try {
-				iv = new InternalVariable( getVariable(), getCDIVariableObject().getVariableDescriptorAsType( type ) );
-			}
-			catch( CDIException e ) {
-				requestFailed( e.getMessage(), null );
-			}
-			return iv;
-		}
-
-		private synchronized ICDIVariable getCDIVariable() throws DebugException {
-			if ( fCDIVariable == null ) {
-				try {
-					fCDIVariable = getCDIVariableObject().createVariable( );
-				}
-				catch( CDIException e ) {
-					requestFailed( e.getMessage(), null );
-				}
-			}
-			return fCDIVariable;
-		}
-
-		private void setCDIVariable( ICDIVariable variable ) {
-			fCDIVariable = variable;
-		}
-
-		private ICDIVariableDescriptor getCDIVariableObject() {
-			if ( fCDIVariable != null ) {
-				return fCDIVariable;
-			}
-			return fCDIVariableObject;
-		}
-
-		private void setCDIVariableObject( ICDIVariableDescriptor variableObject ) {
-			fCDIVariableObject = variableObject;
-		}
-
-		String getQualifiedName() throws DebugException {
-			if ( fQualifiedName == null ) {
-				try {
-					fQualifiedName = (fCDIVariableObject != null) ? fCDIVariableObject.getQualifiedName() : null;
-				}
-				catch( CDIException e ) {
-					requestFailed( e.getMessage(), null );
-				}
-			}
-			return fQualifiedName;
-		}
-
-		CType getType() throws DebugException {
-			if ( fType == null ) {
-				ICDIVariableDescriptor varObject = getCDIVariableObject();
-				if ( varObject != null ) {
-					synchronized( this ) {
-						if ( fType == null ) {
-							try {
-								fType = new CType( varObject.getType() );
-							}
-							catch( CDIException e ) {
-								requestFailed( e.getMessage(), null );
-							}
-						}
-					}
-				}
-			}
-			return fType;
-		}
-
-		synchronized void invalidate( boolean destroy ) {
-			try {
-				if ( destroy && fCDIVariable != null )
-					fCDIVariable.dispose();
-			}
-			catch( CDIException e ) {
-				logError( e.getMessage() );
-			}
-			invalidateValue();
-			setCDIVariable( null );
-			if ( fType != null )
-				fType.dispose();
-			fType = null;
-		}
-
-		void dispose( boolean destroy ) {
-			invalidate( destroy );
-		}
-
-		boolean isSameVariable( ICDIVariable cdiVar ) {
-			return ( fCDIVariable != null ) ? fCDIVariable.equals( cdiVar ) : false;
-		}
-
-		int sizeof() {
-			if ( getCDIVariableObject() != null ) {
-				try {
-					return getCDIVariableObject().sizeof();
-				}
-				catch( CDIException e ) {
-				}
-			}
-			return 0;
-		}
-
-		boolean isArgument() {
-			return ( getCDIVariableObject() instanceof ICDIArgumentDescriptor );
-		}
-
-		void setValue( String expression ) throws DebugException {
-			ICDIVariable cdiVariable = null;
-			try {
-				cdiVariable = getCDIVariable();
-				if ( cdiVariable != null )
-					cdiVariable.setValue( expression );
-				else
-					requestFailed( CoreModelMessages.getString( "CModificationVariable.0" ), null ); //$NON-NLS-1$
-			}
-			catch( CDIException e ) {
-				targetRequestFailed( e.getMessage(), null );
-			}
-		}
-
-		void setValue( ICValue value ) {
-			fValue = value;
-		}
-
-		synchronized ICValue getValue() throws DebugException {
-			if ( fValue.equals( CValueFactory.NULL_VALUE ) ) {
-				ICDIVariable var = getCDIVariable();
-				if ( var != null ) {
-					try {
-						ICDIValue cdiValue = var.getValue();
-						if ( cdiValue != null ) {
-							ICDIType cdiType = cdiValue.getType();
-							if ( cdiValue instanceof ICDIArrayValue && cdiType != null ) {
-								ICType type = new CType( cdiType );
-								if ( type.isArray() ) {
-									int[] dims = type.getArrayDimensions();
-									if ( dims.length > 0 && dims[0] > 0 )
-										fValue = CValueFactory.createIndexedValue( getVariable(), (ICDIArrayValue)cdiValue, 0, dims[0] );
-								}
-							}
-							else {
-								fValue = CValueFactory.createValue( getVariable(), cdiValue );
-							}
-						}
-					}
-					catch( CDIException e ) {
-						requestFailed( e.getMessage(), e );
-					}
-				}
-			}
-			return fValue;
-		}
-		
-		void invalidateValue() {
-			if ( fValue instanceof AbstractCValue ) {
-				((AbstractCValue)fValue).dispose();
-				fValue = CValueFactory.NULL_VALUE;
-			}
-		}
-
-		boolean isChanged() {
-			return fChanged;
-		}
-
-		synchronized void setChanged( boolean changed ) {
-			if ( changed ) {
-				invalidateValue();
-			}
-			if ( fValue instanceof AbstractCValue ) {
-				((AbstractCValue)fValue).setChanged( changed );
-			}
-			fChanged = changed;
-		}
-
-		synchronized void preserve() {
-			setChanged( false );
-			if ( fValue instanceof AbstractCValue ) {
-				((AbstractCValue)fValue).preserve();
-			}
-		}
-
-		CVariable getVariable() {
-			return fVariable;
-		}
-
-		private void setVariable( CVariable variable ) {
-			fVariable = variable;
-		}
-
-		void resetValue() {
-			if ( fValue instanceof AbstractCValue ) {
-				((AbstractCValue)fValue).reset();
-			}
-		}
-
-		boolean isEditable() throws DebugException {
-			ICDIVariable var = getCDIVariable();
-			if ( var != null ) {
-				try {
-					return var.isEditable();
-				}
-				catch( CDIException e ) {
-				}
-			}
-			return false;
-		}
-		/**
-		 * Compares the underlying variable objects.
-		 * @see java.lang.Object#equals(java.lang.Object)
-		 */
-		public boolean equals( Object obj ) {
-			if ( obj instanceof InternalVariable ) {
-				return getCDIVariableObject().equals( ((InternalVariable)obj).getCDIVariableObject() );
-			}
-			return false;
-		}
-
-		boolean sameVariable( ICDIVariableDescriptor vo ) {
-			return getCDIVariableObject().equals( vo );
-		}
 	}
 
 	/**
@@ -332,12 +64,12 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	/**
 	 * The original internal variable.
 	 */
-	private InternalVariable fOriginal;
+	private IInternalVariable fOriginal;
 
 	/**
 	 * The shadow internal variable used for casting.
 	 */
-	private InternalVariable fShadow;
+	private IInternalVariable fShadow;
 
 	/**
 	 * The name of this variable.
@@ -360,7 +92,7 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	protected CVariable( CDebugElement parent, ICDIVariableDescriptor cdiVariableObject ) {
 		super( parent );
 		if ( cdiVariableObject != null ) {
-			fName = cdiVariableObject.getName();
+			setName( cdiVariableObject.getName() );
 			createOriginal( cdiVariableObject );
 		}
 		fIsEnabled = ( parent instanceof AbstractCValue ) ? ((AbstractCValue)parent).getParentVariable().isEnabled() : !isBookkeepingEnabled();
@@ -373,7 +105,7 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	protected CVariable( CDebugElement parent, ICDIVariableDescriptor cdiVariableObject, String errorMessage ) {
 		super( parent );
 		if ( cdiVariableObject != null ) {
-			fName = cdiVariableObject.getName();
+			setName( cdiVariableObject.getName() );
 			createOriginal( cdiVariableObject );
 		}
 		fIsEnabled = !isBookkeepingEnabled();
@@ -389,7 +121,7 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	public ICType getType() throws DebugException {
 		if ( isDisposed() )
 			return null;
-		InternalVariable iv = getCurrentInternalVariable();
+		IInternalVariable iv = getCurrentInternalVariable();
 		return ( iv != null ) ? iv.getType() : null;
 	}
 
@@ -408,7 +140,7 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	 * @see org.eclipse.cdt.debug.core.model.ICVariable#setEnabled(boolean)
 	 */
 	public void setEnabled( boolean enabled ) throws DebugException {
-		InternalVariable iv = getOriginal();
+		IInternalVariable iv = getOriginal();
 		if ( iv != null )
 			iv.dispose( true );
 		iv = getShadow();
@@ -433,7 +165,7 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	 * @see org.eclipse.cdt.debug.core.model.ICVariable#isArgument()
 	 */
 	public boolean isArgument() {
-		InternalVariable iv = getOriginal();
+		IInternalVariable iv = getOriginal();
 		return ( iv != null ) ? iv.isArgument() : false;
 	}
 
@@ -444,7 +176,7 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	 */
 	public IValue getValue() throws DebugException {
 		if ( !isDisposed() && isEnabled() ) {
-			InternalVariable iv = getCurrentInternalVariable();
+			IInternalVariable iv = getCurrentInternalVariable();
 			if ( iv != null ) {
 				try {
 					return iv.getValue();
@@ -484,7 +216,7 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	public boolean hasValueChanged() throws DebugException {
 		if ( isDisposed() )
 			return false;
-		InternalVariable iv = getCurrentInternalVariable(); 
+		IInternalVariable iv = getCurrentInternalVariable(); 
 		return ( iv != null ) ? iv.isChanged() : false;
 	}
 
@@ -539,9 +271,9 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	 * @see org.eclipse.cdt.debug.core.model.ICastToArray#castToArray(int, int)
 	 */
 	public void castToArray( int startIndex, int length ) throws DebugException {
-		InternalVariable current = getCurrentInternalVariable();
+		IInternalVariable current = getCurrentInternalVariable();
 		if ( current != null ) {
-			InternalVariable newVar = current.createShadow( startIndex, length );
+			IInternalVariable newVar = current.createShadow( startIndex, length );
 			if ( getShadow() != null )
 				getShadow().dispose( true );
 			setShadow( newVar );
@@ -557,7 +289,7 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	 * @see org.eclipse.debug.core.model.IValueModification#setValue(java.lang.String)
 	 */
 	public void setValue( String expression ) throws DebugException {
-		InternalVariable iv = getCurrentInternalVariable();
+		IInternalVariable iv = getCurrentInternalVariable();
 		if ( iv != null ) {
 			String newExpression = processExpression( expression );
 			iv.setValue( newExpression );
@@ -635,9 +367,9 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	 * @see org.eclipse.cdt.debug.core.model.ICastToType#cast(java.lang.String)
 	 */
 	public void cast( String type ) throws DebugException {
-		InternalVariable current = getCurrentInternalVariable();
+		IInternalVariable current = getCurrentInternalVariable();
 		if ( current != null ) {
-			InternalVariable newVar = current.createShadow( type );
+			IInternalVariable newVar = current.createShadow( type );
 			if ( getShadow() != null )
 				getShadow().dispose( true );
 			setShadow( newVar );
@@ -653,11 +385,11 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	 * @see org.eclipse.cdt.debug.core.model.ICastToType#restoreOriginal()
 	 */
 	public void restoreOriginal() throws DebugException {
-		InternalVariable oldVar = getShadow();
+		IInternalVariable oldVar = getShadow();
 		setShadow( null );
 		if ( oldVar != null )
 			oldVar.dispose( true );
-		InternalVariable iv = getOriginal();
+		IInternalVariable iv = getOriginal();
 		if ( iv != null )
 			iv.invalidateValue();
 		// If casting of variable to a type or array causes an error, the status 
@@ -680,7 +412,7 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	 * @see org.eclipse.cdt.debug.core.cdi.event.ICDIEventListener#handleDebugEvents(org.eclipse.cdt.debug.core.cdi.event.ICDIEvent[])
 	 */
 	public void handleDebugEvents( ICDIEvent[] events ) {
-		InternalVariable iv = getCurrentInternalVariable();
+		IInternalVariable iv = getCurrentInternalVariable();
 		if ( iv == null )
 			return;
 		for( int i = 0; i < events.length; i++ ) {
@@ -707,7 +439,7 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 		if ( hasErrors() ) {
 			resetStatus();
 			changed = true;
-			InternalVariable iv = getCurrentInternalVariable();
+			IInternalVariable iv = getCurrentInternalVariable();
 			if ( iv != null )
 				iv.invalidateValue();
 		}
@@ -716,32 +448,32 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	}
 
 	private void handleChangedEvent( ICDIChangedEvent event ) {
-		InternalVariable iv = getCurrentInternalVariable();
+		IInternalVariable iv = getCurrentInternalVariable();
 		if ( iv != null ) {
 			iv.setChanged( true );
 			fireChangeEvent( DebugEvent.STATE );
 		}
 	}
 
-	private InternalVariable getCurrentInternalVariable() {
+	private IInternalVariable getCurrentInternalVariable() {
 		if ( getShadow() != null )
 			return getShadow();
 		return getOriginal();
 	}
 
-	private InternalVariable getOriginal() {
+	private IInternalVariable getOriginal() {
 		return fOriginal;
 	}
 
-	private void setOriginal( InternalVariable original ) {
+	protected void setOriginal( IInternalVariable original ) {
 		fOriginal = original;
 	}
 
-	private InternalVariable getShadow() {
+	private IInternalVariable getShadow() {
 		return fShadow;
 	}
 
-	private void setShadow( InternalVariable shadow ) {
+	private void setShadow( IInternalVariable shadow ) {
 		fShadow = shadow;
 	}
 
@@ -755,25 +487,21 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 		return result;
 	}
 
-	private void createOriginal( ICDIVariableDescriptor vo ) {
+	abstract protected void createOriginal( ICDIVariableDescriptor vo );
-		if ( vo != null )
-			fName = vo.getName();
-		setOriginal( new InternalVariable( this, vo ) );
-	}
 
 	protected boolean hasErrors() {
 		return !isOK();
 	}
 
 	protected void setChanged( boolean changed ) {
-		InternalVariable iv = getCurrentInternalVariable();
+		IInternalVariable iv = getCurrentInternalVariable();
 		if ( iv != null ) {
 			iv.setChanged( changed );
 		}
 	}
 
 	protected void resetValue() {
-		InternalVariable iv = getCurrentInternalVariable();
+		IInternalVariable iv = getCurrentInternalVariable();
 		if ( iv != null ) {
 			resetStatus();
 			iv.resetValue();
@@ -795,7 +523,7 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	}
 
 	protected int sizeof() {
-		InternalVariable iv = getCurrentInternalVariable(); 
+		IInternalVariable iv = getCurrentInternalVariable(); 
 		return ( iv != null ) ? iv.sizeof() : -1;
 	}
 
@@ -805,15 +533,15 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	 */
 	public boolean equals( Object obj ) {
 		if ( obj instanceof CVariable ) {
-			InternalVariable iv = getOriginal();
+			IInternalVariable iv = getOriginal();
 			return ( iv != null ) ? iv.equals( ((CVariable)obj).getOriginal() ) : false;
 		}
 		return false;
 	}
 
 	protected boolean sameVariable( ICDIVariableDescriptor vo ) {
-		InternalVariable iv = getOriginal();
+		IInternalVariable iv = getOriginal();
-		return ( iv != null && iv.sameVariable( vo ) );
+		return ( iv != null && iv.isSameDescriptor( vo ) );
 	}
 
 	protected void setFormat( CVariableFormat format ) {
@@ -824,7 +552,7 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	 * @see org.eclipse.cdt.debug.core.model.ICVariable#getExpressionString()
 	 */
 	public String getExpressionString() throws DebugException {
-		InternalVariable iv = getCurrentInternalVariable(); 
+		IInternalVariable iv = getCurrentInternalVariable(); 
 		return ( iv != null ) ? iv.getQualifiedName() : null;
 	}
 
@@ -833,14 +561,14 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	 */
 	protected void preserve() {
 		resetStatus();
-		InternalVariable iv = getCurrentInternalVariable(); 
+		IInternalVariable iv = getCurrentInternalVariable(); 
 		if ( iv != null )
 			iv.preserve();
 	}
 
 	protected void internalDispose( boolean destroy ) {
 		getCDISession().getEventManager().removeEventListener( this );
-		InternalVariable iv = getOriginal();
+		IInternalVariable iv = getOriginal();
 		if ( iv != null )
 			iv.dispose( destroy );
 		iv = getShadow();
@@ -855,4 +583,15 @@ public class CVariable extends AbstractCVariable implements ICDIEventListener {
 	protected void setDisposed( boolean isDisposed ) {
 		fIsDisposed = isDisposed;
 	}
+
+	protected void invalidateValue() {
+		resetStatus();
+		IInternalVariable iv = getCurrentInternalVariable();
+		if ( iv != null )
+			iv.invalidateValue();
+	}
+	
+	protected void setName( String name ) {
+		fName = name;
+	}
 }

debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/model/CVariableFactory.java

@@ -25,12 +25,12 @@ import org.eclipse.core.runtime.Path;
  */
 public class CVariableFactory {
 
-	public static CVariable createVariable( CDebugElement parent, ICDIVariableDescriptor cdiVariableObject ) {
+	public static CLocalVariable createLocalVariable( CDebugElement parent, ICDIVariableDescriptor cdiVariableObject ) {
-		return new CVariable( parent, cdiVariableObject );
+		return new CLocalVariable( parent, cdiVariableObject );
 	}
 
-	public static CVariable createVariableWithError( CDebugElement parent, ICDIVariableDescriptor cdiVariableObject, String message ) {
+	public static CLocalVariable createLocalVariableWithError( CDebugElement parent, ICDIVariableDescriptor cdiVariableObject, String message ) {
-		return new CVariable( parent, cdiVariableObject, message );
+		return new CLocalVariable( parent, cdiVariableObject, message );
 	}
 
 	public static IGlobalVariableDescriptor createGlobalVariableDescriptor( final String name, final IPath path ) {

debug/org.eclipse.cdt.debug.mi.core/ChangeLog

@@ -1,3 +1,15 @@
+2005-07-28 Alain Magloire
+	Fix Pr 104421: The register did not update.
+	* cdi/org/eclipse/cdt/debug/mi/core/cdi/RegisterManager.java
+	* cdi/org/eclipse/cdt/debug/mi/core/cdi/model/Register.java
+	* cdi/org/eclipse/cdt/debug/mi/core/cdi/model/StackFrame.java
+	* cdi/org/eclipse/cdt/debug/mi/core/cdi/model/Target.java
+	* cdi/org/eclipse/cdt/debug/mi/core/cdi/model/Thread.java
+	* cdi/org/eclipse/cdt/debug/mi/core/cdi/model/Value.java
+	* cdi/org/eclipse/cdt/debug/mi/core/cdi/model/Variable.java
+	* cdi/org/eclipse/cdt/debug/mi/core/cdi/model/VariableDescriptor.java
+	* cdi/org/eclipse/cdt/debug/mi/core/cdi/model/type/ArrayValue.java
+
 2005-07-26 Alain Magloire
 	Fix for 92446
 	* cdi/org/eclipse/cdt/debug/mi/core/cdi/VariableManager.java

debug/org.eclipse.cdt.debug.mi.core/cdi/org/eclipse/cdt/debug/mi/core/cdi/RegisterManager.java

@@ -20,10 +20,14 @@ import org.eclipse.cdt.debug.core.cdi.model.ICDIRegisterDescriptor;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIRegisterGroup;
 import org.eclipse.cdt.debug.mi.core.MIException;
 import org.eclipse.cdt.debug.mi.core.MISession;
+import org.eclipse.cdt.debug.mi.core.cdi.model.LocalVariable;
 import org.eclipse.cdt.debug.mi.core.cdi.model.Register;
 import org.eclipse.cdt.debug.mi.core.cdi.model.RegisterDescriptor;
 import org.eclipse.cdt.debug.mi.core.cdi.model.RegisterGroup;
+import org.eclipse.cdt.debug.mi.core.cdi.model.StackFrame;
 import org.eclipse.cdt.debug.mi.core.cdi.model.Target;
+import org.eclipse.cdt.debug.mi.core.cdi.model.Thread;
+import org.eclipse.cdt.debug.mi.core.cdi.model.Variable;
 import org.eclipse.cdt.debug.mi.core.cdi.model.VariableDescriptor;
 import org.eclipse.cdt.debug.mi.core.command.CommandFactory;
 import org.eclipse.cdt.debug.mi.core.command.MIDataListChangedRegisters;
@@ -46,11 +50,13 @@ import org.eclipse.cdt.debug.mi.core.output.MIVarUpdateInfo;
 public class RegisterManager extends Manager {
 
 	Map regsMap;
+	Map varMap;
 	MIVarChange[] noChanges = new MIVarChange[0];
 
 	public RegisterManager(Session session) {
 		super(session, true);
 		regsMap = new Hashtable();
+		varMap = new Hashtable();
 		// The register bookkeeping provides better update control.
 		setAutoUpdate( true );
 	}
@@ -64,6 +70,15 @@ public class RegisterManager extends Manager {
 		return regsList;
 	}
 
+	synchronized List getVariableList(Target target) {
+		List varList = (List)varMap.get(target);
+		if (varList == null) {
+			varList = Collections.synchronizedList(new ArrayList());
+			varMap.put(target, varList);
+		}
+		return varList;
+	}
+
 	public ICDIRegisterGroup[] getRegisterGroups(Target target) throws CDIException {
 		RegisterGroup group = new RegisterGroup(target, "Main"); //$NON-NLS-1$
 		return new ICDIRegisterGroup[] { group };
@@ -152,6 +167,33 @@ public class RegisterManager extends Manager {
 		}
 	}
 
+	public Variable createVariable(StackFrame frame, String reg) throws CDIException {
+		Target target = (Target)frame.getTarget();
+		Thread currentThread = (Thread)target.getCurrentThread();
+		StackFrame currentFrame = currentThread.getCurrentStackFrame();
+		target.setCurrentThread(frame.getThread(), false);
+		((Thread)frame.getThread()).setCurrentStackFrame(frame, false);
+		try {
+			MISession mi = target.getMISession();
+			CommandFactory factory = mi.getCommandFactory();
+			MIVarCreate var = factory.createMIVarCreate(reg);
+			mi.postCommand(var);
+			MIVarCreateInfo info = var.getMIVarCreateInfo();
+			if (info == null) {
+				throw new CDIException(CdiResources.getString("cdi.Common.No_answer")); //$NON-NLS-1$
+			}
+			Variable variable = new LocalVariable(target, null, frame, reg, null, 0, 0, info.getMIVar());
+			List varList = getVariableList(target);
+			varList.add(variable);
+			return variable;
+		} catch (MIException e) {
+			throw new MI2CDIException(e);
+		} finally {
+			target.setCurrentThread(currentThread, false);
+			currentThread.setCurrentStackFrame(currentFrame, false);
+		}
+	}
+
 	/**
 	 * Use by the eventManager to find the Register;
 	 */
@@ -192,6 +234,13 @@ public class RegisterManager extends Manager {
 
 	public void update(Target target) throws CDIException {
 		MISession mi = target.getMISession();
+
+//		Variable[] vars = getVariables(target);
+//		for (int i = 0; i < vars.length; ++i) {
+//			removeMIVar(mi, vars[i].getMIVar());
+//			List varList = getVariableList(target);
+//			varList.remove(vars[i]);
+//		}
 		CommandFactory factory = mi.getCommandFactory();
 		MIDataListChangedRegisters changed = factory.createMIDataListChangedRegisters();
 		try {
@@ -251,6 +300,14 @@ public class RegisterManager extends Manager {
 		return new Register[0];
 	}
 
+	private Variable[] getVariables(Target target) {
+		List varList = (List)varMap.get(target);
+		if (varList != null) {
+			return (Variable[]) varList.toArray(new Variable[varList.size()]);
+		}
+		return new Register[0];
+	}
+
 	/**
 	 * Return the Element with this thread/stackframe, and with this name.
 	 * null is return if the element is not in the cache.

debug/org.eclipse.cdt.debug.mi.core/cdi/org/eclipse/cdt/debug/mi/core/cdi/model/Register.java

@@ -10,12 +10,24 @@
  *******************************************************************************/
 package org.eclipse.cdt.debug.mi.core.cdi.model;
 
+import java.util.List;
+
 import org.eclipse.cdt.debug.core.cdi.CDIException;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIRegister;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIStackFrame;
 import org.eclipse.cdt.debug.core.cdi.model.ICDITarget;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIValue;
+import org.eclipse.cdt.debug.mi.core.MIException;
+import org.eclipse.cdt.debug.mi.core.MISession;
+import org.eclipse.cdt.debug.mi.core.cdi.CdiResources;
+import org.eclipse.cdt.debug.mi.core.cdi.ExpressionManager;
+import org.eclipse.cdt.debug.mi.core.cdi.MI2CDIException;
 import org.eclipse.cdt.debug.mi.core.cdi.RegisterManager;
 import org.eclipse.cdt.debug.mi.core.cdi.Session;
+import org.eclipse.cdt.debug.mi.core.command.CommandFactory;
+import org.eclipse.cdt.debug.mi.core.command.MIVarCreate;
 import org.eclipse.cdt.debug.mi.core.output.MIVar;
+import org.eclipse.cdt.debug.mi.core.output.MIVarCreateInfo;
 
 /**
  */
@@ -57,10 +69,34 @@ public class Register extends Variable implements ICDIRegister {
 		return new Register(target, thread, frame, name, fullName, pos, depth, miVar);
 	}
 
+	/* (non-Javadoc)
+	 * @see org.eclipse.cdt.debug.core.cdi.model.ICDIVariable#dispose()
+	 */
 	public void dispose() throws CDIException {
 		ICDITarget target = getTarget();
 		RegisterManager regMgr = ((Session)target.getSession()).getRegisterManager();
 		regMgr.destroyRegister(this);
 	}
 
+	/* (non-Javadoc)
+	 * @see org.eclipse.cdt.debug.core.cdi.model.ICDIRegister#getValue(org.eclipse.cdt.debug.core.cdi.model.ICDIStackFrame)
+	 */
+	public ICDIValue getValue(ICDIStackFrame context) throws CDIException {
+		Session session = (Session)getTarget().getSession();
+		RegisterManager mgr = session.getRegisterManager();
+		Variable var = mgr.createVariable((StackFrame)context, getQualifiedName());
+		return var.getValue();
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.cdt.debug.core.cdi.model.ICDIRegister#equals(org.eclipse.cdt.debug.core.cdi.model.ICDIRegister)
+	 */
+	public boolean equals(ICDIRegister register) {
+		if (register instanceof Register) {
+			Register reg = (Register) register;
+			return super.equals(reg);
+		}
+		return super.equals(register);
+	}
+
 }

debug/org.eclipse.cdt.debug.mi.core/cdi/org/eclipse/cdt/debug/mi/core/cdi/model/StackFrame.java

@@ -14,7 +14,9 @@ import java.math.BigInteger;
 
 import org.eclipse.cdt.debug.core.cdi.CDIException;
 import org.eclipse.cdt.debug.core.cdi.ICDILocator;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIArgument;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIArgumentDescriptor;
+import org.eclipse.cdt.debug.core.cdi.model.ICDILocalVariable;
 import org.eclipse.cdt.debug.core.cdi.model.ICDILocalVariableDescriptor;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIStackFrame;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIThread;
@@ -109,6 +111,32 @@ public class StackFrame extends CObject implements ICDIStackFrame {
 		return localDescs;
 	}
 
+	/* (non-Javadoc)
+	 * @see org.eclipse.cdt.debug.core.cdi.model.ICDIStackFrame#createArgument(org.eclipse.cdt.debug.core.cdi.model.ICDIArgumentDescriptor)
+	 */
+	public ICDIArgument createArgument(ICDIArgumentDescriptor varDesc) throws CDIException {
+		if (varDesc instanceof ArgumentDescriptor) {
+			Session session = (Session)getTarget().getSession();
+			VariableManager mgr = session.getVariableManager();
+			return mgr.createArgument((ArgumentDescriptor)varDesc);
+		}
+		return null;
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.cdt.debug.core.cdi.model.ICDIStackFrame#createLocalVariable(org.eclipse.cdt.debug.core.cdi.model.ICDILocalVariableDescriptor)
+	 */
+	public ICDILocalVariable createLocalVariable(ICDILocalVariableDescriptor varDesc) throws CDIException {
+		if (varDesc instanceof ArgumentDescriptor) {
+			return createArgument((ICDIArgumentDescriptor)varDesc);
+		} else if (varDesc instanceof LocalVariableDescriptor) {
+			Session session = (Session)getTarget().getSession();
+			VariableManager mgr = session.getVariableManager();
+			return mgr.createLocalVariable((LocalVariableDescriptor)varDesc);			
+		}
+		return null;
+	}
+
 	/**
 	 * @see org.eclipse.cdt.debug.core.cdi.model.ICDIStackFrame#getLocation()
 	 */

debug/org.eclipse.cdt.debug.mi.core/cdi/org/eclipse/cdt/debug/mi/core/cdi/model/Target.java

@@ -25,10 +25,14 @@ import org.eclipse.cdt.debug.core.cdi.model.ICDIBreakpoint;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIExceptionpoint;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIExpression;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIFunctionBreakpoint;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIGlobalVariable;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIGlobalVariableDescriptor;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIInstruction;
 import org.eclipse.cdt.debug.core.cdi.model.ICDILineBreakpoint;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIMemoryBlock;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIMixedInstruction;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIRegister;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIRegisterDescriptor;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIRegisterGroup;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIRuntimeOptions;
 import org.eclipse.cdt.debug.core.cdi.model.ICDISharedLibrary;
@@ -37,7 +41,6 @@ import org.eclipse.cdt.debug.core.cdi.model.ICDIStackFrame;
 import org.eclipse.cdt.debug.core.cdi.model.ICDITarget;
 import org.eclipse.cdt.debug.core.cdi.model.ICDITargetConfiguration;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIThread;
-import org.eclipse.cdt.debug.core.cdi.model.ICDIVariableDescriptor;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIWatchpoint;
 import org.eclipse.cdt.debug.mi.core.CoreProcess;
 import org.eclipse.cdt.debug.mi.core.MIException;
@@ -1066,7 +1069,7 @@ public class Target extends SessionObject implements ICDITarget {
 	/* (non-Javadoc)
 	 * @see org.eclipse.cdt.debug.core.cdi.model.ICDITarget#getGlobalVariableDescriptors(java.lang.String, java.lang.String, java.lang.String)
 	 */
-	public ICDIVariableDescriptor getGlobalVariableDescriptors(String filename, String function, String name) throws CDIException {
+	public ICDIGlobalVariableDescriptor getGlobalVariableDescriptors(String filename, String function, String name) throws CDIException {
 		VariableManager varMgr = ((Session)getSession()).getVariableManager();
 		return varMgr.getGlobalVariableDescriptor(this, filename, function, name);
 	}
@@ -1097,4 +1100,28 @@ public class Target extends SessionObject implements ICDITarget {
 		return fConfiguration;
 	}
 
+	/* (non-Javadoc)
+	 * @see org.eclipse.cdt.debug.core.cdi.model.ICDITarget#createGlobalVariable(org.eclipse.cdt.debug.core.cdi.model.ICDIGlobalVariableDescriptor)
+	 */
+	public ICDIGlobalVariable createGlobalVariable(ICDIGlobalVariableDescriptor varDesc) throws CDIException {
+		if (varDesc instanceof GlobalVariableDescriptor) {
+			VariableManager varMgr = ((Session)getSession()).getVariableManager();
+			return varMgr.createGlobalVariable((GlobalVariableDescriptor)varDesc);
+		}
+		return null;
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.cdt.debug.core.cdi.model.ICDITarget#createRegister(org.eclipse.cdt.debug.core.cdi.model.ICDIRegisterDescriptor)
+	 */
+	public ICDIRegister createRegister(ICDIRegisterDescriptor varDesc) throws CDIException {
+		if (varDesc instanceof RegisterDescriptor) {
+			Session session = (Session)getTarget().getSession();
+			RegisterManager mgr = session.getRegisterManager();
+			return mgr.createRegister((RegisterDescriptor)varDesc);			
+		}
+		return null;		
+	}
+
+
 }

debug/org.eclipse.cdt.debug.mi.core/cdi/org/eclipse/cdt/debug/mi/core/cdi/model/Thread.java

@@ -20,6 +20,7 @@ import org.eclipse.cdt.debug.core.cdi.model.ICDIBreakpoint;
 import org.eclipse.cdt.debug.core.cdi.model.ICDISignal;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIStackFrame;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIThread;
+import org.eclipse.cdt.debug.core.cdi.model.ICDIThreadStorage;
 import org.eclipse.cdt.debug.core.cdi.model.ICDIThreadStorageDescriptor;
 import org.eclipse.cdt.debug.mi.core.MIException;
 import org.eclipse.cdt.debug.mi.core.MISession;
@@ -499,4 +500,16 @@ public class Thread extends CObject implements ICDIThread {
 		return varMgr.getThreadStorageDescriptors(this);
 	}
 
+	/* (non-Javadoc)
+	 * @see org.eclipse.cdt.debug.core.cdi.model.ICDIThread#createThreadStorage(org.eclipse.cdt.debug.core.cdi.model.ICDIThreadStorageDescriptor)
+	 */
+	public ICDIThreadStorage createThreadStorage(ICDIThreadStorageDescriptor varDesc) throws CDIException {
+		if (varDesc instanceof ThreadStorageDescriptor) {
+			Session session = (Session)getTarget().getSession();
+			VariableManager varMgr = session.getVariableManager();
+			return varMgr.createThreadStorage((ThreadStorageDescriptor)varDesc);
+		}
+		return null;
+	}
+
 }

debug/org.eclipse.cdt.debug.mi.core/cdi/org/eclipse/cdt/debug/mi/core/cdi/model/Value.java

@@ -25,22 +25,22 @@ import org.eclipse.cdt.debug.mi.core.output.MIVarEvaluateExpressionInfo;
  */
 public class Value extends CObject implements ICDIValue {
 
-	protected Variable variable;
+	protected Variable fVariable;
 
 	public Value(Variable v) {
 		super((Target)v.getTarget());
-		variable = v;
+		fVariable = v;
 	}
 
-	protected Variable getVariable() {
+	protected Variable getVariable() throws CDIException {
-		return variable;
+		return fVariable;
 	}
 
 	/**
 	 * @see org.eclipse.cdt.debug.core.cdi.model.ICDIValue#getTypeName()
 	 */
 	public String getTypeName() throws CDIException {
-		return variable.getTypeName();
+		return getVariable().getTypeName();
 	}
 
 	/**
@@ -48,15 +48,15 @@ public class Value extends CObject implements ICDIValue {
 	 */
 	public String getValueString() throws CDIException {
 		// make sure the variable is updated.
-		if (! variable.isUpdated()) {
+		if (! getVariable().isUpdated()) {
-			variable.update();
+			getVariable().update();
 		}
 
 		String result = ""; //$NON-NLS-1$
 		MISession mi = ((Target)getTarget()).getMISession();
 		CommandFactory factory = mi.getCommandFactory();
 		MIVarEvaluateExpression var =
-			factory.createMIVarEvaluateExpression(variable.getMIVar().getVarName());
+			factory.createMIVarEvaluateExpression(getVariable().getMIVar().getVarName());
 		try {
 			mi.postCommand(var);
 			MIVarEvaluateExpressionInfo info = var.getMIVarEvaluateExpressionInfo();
@@ -74,7 +74,7 @@ public class Value extends CObject implements ICDIValue {
 	 * @see org.eclipse.cdt.debug.core.cdi.model.ICDIValue#getVariables()
 	 */	
 	public int getChildrenNumber() throws CDIException {
-		return variable.getMIVar().getNumChild();
+		return getVariable().getMIVar().getNumChild();
 	}
 	
 	/**
@@ -106,14 +106,14 @@ public class Value extends CObject implements ICDIValue {
 	 * @see org.eclipse.cdt.debug.core.cdi.model.ICDIValue#getVariables()
 	 */
 	public ICDIVariable[] getVariables() throws CDIException {
-		return variable.getChildren();
+		return getVariable().getChildren();
 	}
 
 	/* (non-Javadoc)
 	 * @see org.eclipse.cdt.debug.core.cdi.model.ICDIValue#getType()
 	 */
 	public ICDIType getType() throws CDIException {
-		return variable.getType();
+		return getVariable().getType();
 	}
 
 }

debug/org.eclipse.cdt.debug.mi.core/cdi/org/eclipse/cdt/debug/mi/core/cdi/model/Variable.java

@@ -422,11 +422,19 @@ public abstract class Variable extends VariableDescriptor implements ICDIVariabl
 	public boolean equals(ICDIVariable var) {
 		if (var instanceof Variable) {
 			Variable variable = (Variable) var;
-			return fMiVar.getVarName().equals(variable.getMIVar().getVarName());
+			return equals(variable);
 		}
 		return super.equals(var);
 	}
 
+	/**
+	 * @param variable
+	 * @return
+	 */
+	public boolean equals(Variable variable) {
+		return fMiVar.getVarName().equals(variable.getMIVar().getVarName());
+	}
+
 	/* (non-Javadoc)
 	 * @see org.eclipse.cdt.debug.core.cdi.model.ICDIVariable#dispose()
 	 */

debug/org.eclipse.cdt.debug.mi.core/cdi/org/eclipse/cdt/debug/mi/core/cdi/model/VariableDescriptor.java

@@ -383,13 +383,13 @@ public abstract class VariableDescriptor extends CObject implements ICDIVariable
 		return mgr.getVariableDescriptorAsType(this, type);
 	}
 
-	/* (non-Javadoc)
+//	/* (non-Javadoc)
-	 * @see org.eclipse.cdt.debug.core.cdi.model.ICDIVariableDescriptor#createVariable()
+//	 * @see org.eclipse.cdt.debug.core.cdi.model.ICDIVariableDescriptor#createVariable()
-	 */
+//	 */
-	public ICDIVariable createVariable() throws CDIException {
+//	public ICDIVariable createVariable() throws CDIException {
-		Session session = (Session)getTarget().getSession();
+//		Session session = (Session)getTarget().getSession();
-		VariableManager mgr = session.getVariableManager();
+//		VariableManager mgr = session.getVariableManager();
-		return mgr.createVariable(this);
+//		return mgr.createVariable(this);
-	}
+//	}
 
 }

debug/org.eclipse.cdt.debug.mi.core/cdi/org/eclipse/cdt/debug/mi/core/cdi/model/type/ArrayValue.java

@@ -44,9 +44,9 @@ public class ArrayValue extends DerivedValue implements ICDIArrayValue {
 		 * GDB time to respond. In the end perhaps we want a UI for this. As it 
 		 * is, let's just make up a number that's 5 seconds for us plus one 
 		 * second for every 128 entries. */
-		int timeout = variable.getMIVar().getNumChild() * 8 + 5000;
+		int timeout = getVariable().getMIVar().getNumChild() * 8 + 5000;
 
-		return variable.getChildren(timeout);
+		return getVariable().getChildren(timeout);
 	}
 
 	/**
@@ -60,6 +60,7 @@ public class ArrayValue extends DerivedValue implements ICDIArrayValue {
 		//}
 
 		// Overload for registers.
+		Variable variable = getVariable();
 		if (variable instanceof Register) {
 			ICDIVariable[] vars = getVariables();