PersistentCorValue merged into PersistentValue

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

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

@@ -381,7 +381,6 @@
     <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, new PersistentCorValue(debugger, CorILFrame.GetArgument(0)), ContaingClass);
+							return new ObjectValue(debugger, new PersistentValue(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, PersistentCorValue pCorValue):base(debugger, pCorValue)
+		internal unsafe ArrayValue(NDebugger debugger, PersistentValue pValue):base(debugger, pValue)
 		{
 			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, PersistentCorValue pCorValue):base(debugger, pCorValue)
+		internal unsafe NullValue(NDebugger debugger, PersistentValue pValue):base(debugger, pValue)
 		{
 			
 		}

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

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

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

@@ -1,87 +0,0 @@
-// <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
-	{
-		NDebugger debugger;
-		
-		ICorDebugValue corValue;
-		// ICorDebugHandleValue can be used to get corValue back after Continue()
-		public ICorDebugHandleValue corHandleValue;
-		PauseSession pauseSessionAtCreation;
-		DebugeeState debugeeStateAtCreation;
-		
-		public NDebugger Debugger {
-			get {
-				return debugger;
-			}
-		}
-		
-		public bool IsExpired {
-			get {
-				if (corHandleValue == null) {
-					return pauseSessionAtCreation != debugger.PauseSession;
-				} else {
-					return debugeeStateAtCreation != debugger.DebugeeState;
-				}
-			}
-		}
-		
-		public ICorDebugValue CorValue {
-			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 = PersistentValue.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.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);
-				}
-			}
-		}
-		
-		public PersistentCorValue(NDebugger debugger, ICorDebugValue corValue)
-		{
-			this.debugger = debugger;
-			if (corValue != null) {
-				this.corHandleValue = corValue.As<ICorDebugHandleValue>();
-				this.corValue = PersistentValue.DereferenceUnbox(corValue);
-			}
-			this.pauseSessionAtCreation = debugger.PauseSession;
-			this.debugeeStateAtCreation = debugger.DebugeeState;
-		}
-	}
-}

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

@@ -30,7 +30,20 @@ namespace Debugger
 		public delegate ICorDebugValue CorValueGetter();
 		
 		
+		NDebugger debugger;
+		
 		ValueGetter getter;
+		ICorDebugValue corValue;
+		// ICorDebugHandleValue can be used to get corValue back after Continue()
+		public ICorDebugHandleValue corHandleValue;
+		PauseSession pauseSessionAtCreation;
+		DebugeeState debugeeStateAtCreation;
+		
+		public NDebugger Debugger {
+			get {
+				return debugger;
+			}
+		}
 		
 		public Value Value {
 			get {
@@ -38,6 +51,49 @@ namespace Debugger
 			}
 		}
 		
+		public bool IsExpired {
+			get {
+				if (corHandleValue == null) {
+					return pauseSessionAtCreation != debugger.PauseSession;
+				} else {
+					return debugeeStateAtCreation != debugger.DebugeeState;
+				}
+			}
+		}
+		
+		public ICorDebugValue CorValue {
+			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 = PersistentValue.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.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);
+				}
+			}
+		}
+		
 		public PersistentValue(ValueGetter getter)
 		{
 			this.getter = getter;
@@ -45,8 +101,15 @@ namespace Debugger
 		
 		public PersistentValue(NDebugger debugger, ICorDebugValue corValue)
 		{
-			Value val = CreateValue(debugger, corValue);
+			this.debugger = debugger;
-			this.getter = delegate { return val; };
+			if (corValue != null) {
+				this.corHandleValue = corValue.As<ICorDebugHandleValue>();
+				this.corValue = PersistentValue.DereferenceUnbox(corValue);
+			}
+			this.pauseSessionAtCreation = debugger.PauseSession;
+			this.debugeeStateAtCreation = debugger.DebugeeState;
+
+			this.getter = delegate { return CreateValue(debugger, corValue); };
 		}
 		
 		public PersistentValue(NDebugger debugger, CorValueGetter corValueGetter)
@@ -89,7 +152,7 @@ namespace Debugger
 		{
 			ICorDebugValue derefed = DereferenceUnbox(corValue);
 			if (derefed == null) {
-				return new NullValue(debugger, new PersistentCorValue(debugger, corValue));
+				return new NullValue(debugger, new PersistentValue(debugger, corValue));
 			}
 			
 			CorElementType type = Value.GetCorType(derefed);
@@ -111,16 +174,16 @@ namespace Debugger
 				case CorElementType.I:
 				case CorElementType.U:
 				case CorElementType.STRING:
-					return new PrimitiveValue(debugger, new PersistentCorValue(debugger, corValue));
+					return new PrimitiveValue(debugger, new PersistentValue(debugger, corValue));
 
 				case CorElementType.ARRAY:
 				case CorElementType.SZARRAY: // Short-cut for single dimension zero lower bound array
-					return new ArrayValue(debugger, new PersistentCorValue(debugger, corValue));
+					return new ArrayValue(debugger, new PersistentValue(debugger, corValue));
 
 				case CorElementType.VALUETYPE:
 				case CorElementType.CLASS:
 				case CorElementType.OBJECT: // Short-cut for Class "System.Object"
-					return new ObjectValue(debugger, new PersistentCorValue(debugger, corValue));
+					return new ObjectValue(debugger, new PersistentValue(debugger, corValue));
 						
 				default: // Unknown type
 					return new UnavailableValue(debugger, "Unknown value type");

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

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

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

@@ -33,7 +33,7 @@ namespace Debugger
 			
 		}
 		
-		internal UnavailableValue(NDebugger debugger, string message):base(debugger, new PersistentCorValue(debugger, null))
+		internal UnavailableValue(NDebugger debugger, string message):base(debugger, new PersistentValue(debugger, (ICorDebugValue)null))
 		{
 			this.message = message;
 		}

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

@@ -16,7 +16,7 @@ namespace Debugger
 	public abstract class Value: RemotingObjectBase
 	{
 		protected NDebugger debugger;
-		PersistentCorValue pCorValue;
+		PersistentValue pValue;
 		
 		public event EventHandler<ValueEventArgs> ValueChanged;
 		
@@ -28,19 +28,19 @@ namespace Debugger
 		
 		protected ICorDebugHandleValue corHandleValue {
 			get {
-				return pCorValue.corHandleValue;
+				return pValue.corHandleValue;
 			}
 		}
 		
 		internal ICorDebugValue CorValue {
 			get {
-				return pCorValue.CorValue;
+				return pValue.CorValue;
 			}
 		}
 		
 		protected ICorDebugHandleValue SoftReference {
 			get {
-				return pCorValue.SoftReference;
+				return pValue.SoftReference;
 			}
 		}
 		
@@ -49,7 +49,7 @@ namespace Debugger
 		/// </summary>
 		public bool IsExpired {
 			get {
-				return pCorValue.IsExpired;
+				return pValue.IsExpired;
 			}
 		}
 		
@@ -111,10 +111,10 @@ namespace Debugger
 			}
 		}
 		
-		protected Value(NDebugger debugger, PersistentCorValue pCorValue)
+		protected Value(NDebugger debugger, PersistentValue pValue)
 		{
 			this.debugger = debugger;
-			this.pCorValue = pCorValue;
+			this.pValue = pValue;
 		}
 		
 		public override string ToString()