ICorDebugValue of Value stored in PersistentCorValue container

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@1546 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/Misc/Debugger/Debugger.Core/Project/Debugger.Core.csproj

@@ -381,6 +381,7 @@
     <Compile Include="Src\Wrappers\CorDebug\ICorDebugChain.cs" />
     <Compile Include="Src\Wrappers\CorDebug\ICorDebugFrame.cs" />
     <Compile Include="Src\Variables\PersistentValue.cs" />
+    <Compile Include="Src\Variables\PersistentCorValue.cs" />
   </ItemGroup>
   <ItemGroup>
     <Content Include="README.TXT" />

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Function.cs

@@ -115,7 +115,7 @@ namespace Debugger
 						return new UnavailableValue(debugger, "Function has expired");
 					} else {
 						try {
-							return new ObjectValue(debugger, CorILFrame.GetArgument(0), ContaingClass);
+							return new ObjectValue(debugger, new PersistentCorValue(debugger, CorILFrame.GetArgument(0)), ContaingClass);
 						} catch (COMException e) {
 							// System.Runtime.InteropServices.COMException (0x80131304): An IL variable is not available at the current native IP.
 							// See Forum-8640

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ArrayValue.cs

@@ -59,7 +59,7 @@ namespace Debugger
 		}
 		
 		
-		internal unsafe ArrayValue(NDebugger debugger, ICorDebugValue corValue):base(debugger, corValue)
+		internal unsafe ArrayValue(NDebugger debugger, PersistentCorValue pCorValue):base(debugger, pCorValue)
 		{
 			corElementType = (CorElementType)CorArrayValue.ElementType;
 			

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/NullValue.cs

@@ -36,7 +36,7 @@ namespace Debugger
 			}
 		}
 
-		internal unsafe NullValue(NDebugger debugger, ICorDebugValue corValue):base(debugger, corValue)
+		internal unsafe NullValue(NDebugger debugger, PersistentCorValue pCorValue):base(debugger, pCorValue)
 		{
 			
 		}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ObjectValue.cs

@@ -85,13 +85,13 @@ namespace Debugger
 			}
 		}
 		
-		internal unsafe ObjectValue(NDebugger debugger, ICorDebugValue corValue):base(debugger, corValue)
+		internal unsafe ObjectValue(NDebugger debugger, PersistentCorValue pCorValue):base(debugger, pCorValue)
 		{
 			corClass = this.CorValue.CastTo<ICorDebugObjectValue>().Class;
 			InitObjectVariable();
 		}
 
-		internal unsafe ObjectValue(NDebugger debugger, ICorDebugValue corValue, ICorDebugClass corClass):base(debugger, corValue)
+		internal unsafe ObjectValue(NDebugger debugger, PersistentCorValue pCorValue, ICorDebugClass corClass):base(debugger, pCorValue)
 		{
 			this.corClass = corClass;
 			InitObjectVariable();
@@ -300,9 +300,9 @@ namespace Debugger
 			} else {
 				ICorDebugClass superClass = corModuleSuperclass.GetClassFromToken(classProps.SuperClassToken);
 				if (corHandleValue != null) {
-					return new ObjectValue(debugger, corHandleValue.As<ICorDebugValue>(), superClass);
+					return new ObjectValue(debugger, new PersistentCorValue(debugger, corHandleValue.As<ICorDebugValue>()), superClass);
 				} else {
-					return new ObjectValue(debugger, CorValue, superClass);
+					return new ObjectValue(debugger, new PersistentCorValue(debugger, CorValue), superClass);
 				}
 			}
 		}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/PersistentCorValue.cs

@@ -0,0 +1,89 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+
+using Debugger.Wrappers.CorDebug;
+
+namespace Debugger
+{
+	/// <summary>
+	/// PersistentValue is a container used to obtain the value of a given object even after continue.
+	/// </summary>
+	public class PersistentCorValue
+	{
+		/// <summary>
+		/// Delegate that is used to get value. This delegate may be called at any time and should never return null.
+		/// </summary>
+		public delegate ICorDebugValue CorValueGetter();
+		
+		
+		NDebugger debugger;
+		
+		public ICorDebugValue CorValue;
+		// ICorDebugHandleValue can be used to get corValue back after Continue()
+		public ICorDebugHandleValue corHandleValue;
+		public PauseSession pauseSessionAtCreation;
+		public DebugeeState debugeeStateAtCreation;
+		
+		public bool IsExpired {
+			get {
+				if (corHandleValue == null) {
+					return pauseSessionAtCreation != debugger.PauseSession;
+				} else {
+					return debugeeStateAtCreation != debugger.DebugeeState;
+				}
+			}
+		}
+		
+		public ICorDebugValue CorValueProp {
+			get {
+				if (this.IsExpired) throw new DebuggerException("CorValue has expired");
+				
+				if (pauseSessionAtCreation == debugger.PauseSession) {
+					return CorValue;
+				} else {
+					if (corHandleValue == null) {
+						throw new DebuggerException("CorValue has expired");
+					} else {
+						CorValue = Value.DereferenceUnbox(corHandleValue.As<ICorDebugValue>());
+						pauseSessionAtCreation = debugger.PauseSession;
+						return CorValue;
+					}
+				}
+			}
+		}
+		
+		public ICorDebugHandleValue SoftReference {
+			get {
+				if (this.IsExpired) throw new DebuggerException("CorValue has expired");
+				
+				if (corHandleValue != null) return corHandleValue;
+				
+				ICorDebugHeapValue2 heapValue = this.CorValueProp.As<ICorDebugHeapValue2>();
+				if (heapValue == null) { // TODO: Investigate - hmmm, value types are not at heap?
+					return null;
+				} else {
+					return heapValue.CreateHandle(CorDebugHandleType.HANDLE_WEAK_TRACK_RESURRECTION);
+				}
+			}
+		}
+		
+		public PersistentCorValue(NDebugger debugger, ICorDebugValue corValue)
+		{
+			this.debugger = debugger;
+			if (corValue != null) {
+				if (corValue.Is<ICorDebugHandleValue>()) {
+					corHandleValue = corValue.As<ICorDebugHandleValue>();
+				}
+				this.CorValue = Value.DereferenceUnbox(corValue);
+			}
+			this.pauseSessionAtCreation = debugger.PauseSession;
+			this.debugeeStateAtCreation = debugger.DebugeeState;
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/PrimitiveValue.cs

@@ -51,7 +51,7 @@ namespace Debugger
 			}
 		}
 
-		internal PrimitiveValue(NDebugger debugger, ICorDebugValue corValue):base(debugger, corValue)
+		internal PrimitiveValue(NDebugger debugger, PersistentCorValue pCorValue):base(debugger, pCorValue)
 		{
 		}
 

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/Value.cs

@@ -16,11 +16,7 @@ namespace Debugger
 	public abstract class Value: RemotingObjectBase
 	{
 		protected NDebugger debugger;
-		ICorDebugValue corValue;
+		PersistentCorValue pCorValue;
-		// ICorDebugHandleValue can be used to get corValue back after Continue()
-		protected ICorDebugHandleValue corHandleValue;
-		PauseSession pauseSessionAtCreation;
-		DebugeeState debugeeStateAtCreation;
 		
 		public event EventHandler<ValueEventArgs> ValueChanged;
 		
@@ -30,36 +26,21 @@ namespace Debugger
 			}
 		}
 		
-		internal ICorDebugValue CorValue {
+		protected ICorDebugHandleValue corHandleValue {
 			get {
-				if (this.IsExpired) throw new DebuggerException("CorValue has expired");
+				return pCorValue.corHandleValue;
+			}
+		}
 		
-				if (pauseSessionAtCreation == debugger.PauseSession) {
+		internal ICorDebugValue CorValue {
-					return corValue;
+			get {
-				} else {
+				return pCorValue.CorValueProp;
-					if (corHandleValue == null) {
-						throw new DebuggerException("CorValue has expired");
-					} else {
-						corValue = DereferenceUnbox(corHandleValue.As<ICorDebugValue>());
-						pauseSessionAtCreation = debugger.PauseSession;
-						return corValue;
-					}
-				}
 			}
 		}
 		
 		protected ICorDebugHandleValue SoftReference {
 			get {
-				if (this.IsExpired) throw new DebuggerException("CorValue has expired");
+				return pCorValue.SoftReference;
-				
-				if (corHandleValue != null) return corHandleValue;
-				
-				ICorDebugHeapValue2 heapValue = this.CorValue.As<ICorDebugHeapValue2>();
-				if (heapValue == null) { // TODO: Investigate - hmmm, value types are not at heap?
-					return null;
-				} else {
-					return heapValue.CreateHandle(CorDebugHandleType.HANDLE_WEAK_TRACK_RESURRECTION);
-				}
 			}
 		}
 		
@@ -68,11 +49,7 @@ namespace Debugger
 		/// </summary>
 		public bool IsExpired {
 			get {
-				if (corHandleValue == null) {
+				return pCorValue.IsExpired;
-					return pauseSessionAtCreation != debugger.PauseSession;
-				} else {
-					return debugeeStateAtCreation != debugger.DebugeeState;
-				}
 			}
 		}
 		
@@ -134,17 +111,10 @@ namespace Debugger
 			}
 		}
 		
-		protected Value(NDebugger debugger, ICorDebugValue corValue)
+		protected Value(NDebugger debugger, PersistentCorValue pCorValue)
 		{
 			this.debugger = debugger;
-			if (corValue != null) {
+			this.pCorValue = pCorValue;
-				if (corValue.Is<ICorDebugHandleValue>()) {
-					corHandleValue = corValue.As<ICorDebugHandleValue>();
-				}
-				this.corValue = DereferenceUnbox(corValue);
-			}
-			this.pauseSessionAtCreation = debugger.PauseSession;
-			this.debugeeStateAtCreation = debugger.DebugeeState;
 		}
 		
 		public override string ToString()
@@ -242,7 +212,7 @@ namespace Debugger
 		{
 			ICorDebugValue derefed = Value.DereferenceUnbox(corValue);
 			if (derefed == null) {
-				return new NullValue(debugger, corValue);
+				return new NullValue(debugger, new PersistentCorValue(debugger, corValue));
 			}
 			
 			CorElementType type = Value.GetCorType(derefed);
@@ -264,16 +234,16 @@ namespace Debugger
 				case CorElementType.I:
 				case CorElementType.U:
 				case CorElementType.STRING:
-					return new PrimitiveValue(debugger, corValue);
+					return new PrimitiveValue(debugger, new PersistentCorValue(debugger, corValue));
 
 				case CorElementType.ARRAY:
 				case CorElementType.SZARRAY: // Short-cut for single dimension zero lower bound array
-					return new ArrayValue(debugger, corValue);
+					return new ArrayValue(debugger, new PersistentCorValue(debugger, corValue));
 
 				case CorElementType.VALUETYPE:
 				case CorElementType.CLASS:
 				case CorElementType.OBJECT: // Short-cut for Class "System.Object"
-					return new ObjectValue(debugger, corValue);
+					return new ObjectValue(debugger, new PersistentCorValue(debugger, corValue));
 						
 				default: // Unknown type
 					return new UnavailableValue(debugger, "Unknown value type");