Better support of pointer values

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

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Service/WindowsDebugger.cs

@@ -386,7 +386,11 @@ namespace ICSharpCode.SharpDevelop.Services
 				return null;
 			}
 			
-			currentTooltipRow = new DynamicTreeDebuggerRow(DebuggedProcess, valueNode);
+			try {
+				currentTooltipRow = new DynamicTreeDebuggerRow(DebuggedProcess, valueNode);
+			} catch (AbortedBecauseDebuggeeResumedException) {
+				return null;
+			}
 			currentTooltipExpression = valueNode.Expression;
 			return new DebuggerGridControl(currentTooltipRow);
 		}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/TreeModel/ValueNode.cs

@@ -75,6 +75,8 @@ namespace Debugger.AddIn.TreeModel
 			
 			if (DebuggingOptions.Instance.ShowValuesInHexadecimal && val.Type.IsInteger) {
 				this.Text = String.Format("0x{0:X}", val.PrimitiveValue);
+			} else if (val.Type.IsPointer) {
+				this.Text = String.Format("0x{0:X}", val.PrimitiveValue);
 			} else {
 				this.Text = val.AsString;
 			}
@@ -86,12 +88,17 @@ namespace Debugger.AddIn.TreeModel
 			}
 			
 			// Note that these return enumerators so they are lazy-evaluated
-			if (val.Type.IsClass || val.Type.IsValueType) {
+			this.ChildNodes = null;
+			if (val.IsNull) {
+			} else if (val.Type.IsClass || val.Type.IsValueType) {
 				this.ChildNodes = Utils.GetChildNodesOfObject(this.Expression, val.Type);
 			} else if (val.Type.IsArray) {
 				this.ChildNodes = Utils.GetChildNodesOfArray(this.Expression, val.ArrayDimensions);
-			} else {
-				this.ChildNodes = null;
+			} else if (val.Type.IsPointer) {
+				Value deRef = val.Dereference();
+				if (deRef != null) {
+					this.ChildNodes = new AbstractNode [] { new ValueNode(deRef) };
+				}
 			}
 			
 			if (DebuggingOptions.Instance.ICorDebugVisualizerEnabled) {
@@ -100,7 +107,7 @@ namespace Debugger.AddIn.TreeModel
 			}
 			
 			// Do last since it may expire the object
-			if (val.Type.IsClass || val.Type.IsValueType) {
+			if ((val.Type.IsClass || val.Type.IsValueType) && !val.IsNull) {
 				this.Text = val.InvokeToString();
 			}
 		}

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

@@ -65,6 +65,7 @@
     <Compile Include="Src\Debugger\SourcecodeSegment.cs" />
     <Compile Include="Src\Expressions\Ast\ArrayIndexerExpression.cs" />
     <Compile Include="Src\Expressions\Ast\CurrentExceptionExpression.cs" />
+    <Compile Include="Src\Expressions\Ast\DereferenceExpression.cs" />
     <Compile Include="Src\Expressions\Ast\EmptyExpression.cs" />
     <Compile Include="Src\Expressions\Ast\LocalVariableIdentifierExpression.cs" />
     <Compile Include="Src\Expressions\Ast\MemberReferenceExpression.cs" />

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Expressions/Ast/DereferenceExpression.cs

@@ -0,0 +1,64 @@
+// <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 System.Collections.Generic;
+
+namespace Debugger.Expressions
+{
+	/// <summary>
+	/// A placeholder expression which can not be evaluated.
+	/// </summary>
+	public class DereferenceExpression: Expression
+	{
+		Expression targetObject;
+		
+		public Expression TargetObject {
+			get { return targetObject; }
+		}
+		
+		public DereferenceExpression(Expression targetObject)
+		{
+			this.targetObject = targetObject;
+		}
+		
+		public override string Code {
+			get { return "*" + targetObject.Code; }
+		}
+		
+		public override string CodeTail {
+			get { return base.CodeTail; }
+		}
+		
+		protected override Value EvaluateInternal(StackFrame context)
+		{
+			Value targetValue = targetObject.Evaluate(context);
+			if (!targetValue.Type.IsPointer) throw new GetValueException("Target object is not a pointer");
+			return targetValue.Dereference();
+		}
+		
+		#region GetHashCode and Equals
+		
+		public override int GetHashCode()
+		{
+			int hashCode = 0;
+			unchecked {
+				if (targetObject != null) hashCode += 1000000007 * targetObject.GetHashCode(); 
+			}
+			return hashCode;
+		}
+		
+		public override bool Equals(object obj)
+		{
+			DereferenceExpression other = obj as DereferenceExpression;
+			if (other == null) return false; 
+			return object.Equals(this.targetObject, other.targetObject);
+		}
+		
+		#endregion
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Values/Value.Primitive.cs

@@ -35,6 +35,9 @@ namespace Debugger
 		/// </summary>
 		public object PrimitiveValue { 
 			get {
+				if (this.Type.IsPointer) {
+					return this.CorValue.CastTo<ICorDebugReferenceValue>().Address;
+				}
 				if (!this.Type.IsPrimitive) throw new DebuggerException("Value is not a primitive type");
 				if (this.Type.IsString) {
 					if (this.IsNull) return null;

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

@@ -143,6 +143,19 @@ namespace Debugger
 			}
 		}
 		
+		/// <summary> Dereferences a pointer type </summary>
+		/// <returns> Returns null for a null pointer </returns>
+		public Value Dereference()
+		{
+			if (!this.Type.IsPointer) throw new DebuggerException("Not a pointer");
+			ICorDebugReferenceValue corRef = this.CorValue.CastTo<ICorDebugReferenceValue>();
+			if (corRef.Value == 0 || corRef.Dereference() == null) {
+				return null;
+			} else {
+				return new Value(this.Process, new DereferenceExpression(this.Expression), corRef.Dereference());
+			}
+		}
+		
 		/// <summary> Copy the acutal value from some other Value object </summary>
 		public void SetValue(Value newValue)
 		{