pimhwang
/
SharpDevelop
mirror of https://github.com/icsharpcode/SharpDevelop.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Expression caching 

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@4745 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61
shortcuts
David Srbecký 16 years ago
parent
a6fb1caa46
commit
4162f7ab31
6 changed files with 369 additions and 224 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Debugger.Core.csproj
  2. 3
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Control/Process-StateControl.cs
  3. 9
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Control/Process.cs
  4. 496
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Expressions/ExpressionEvaluator.cs
  5. 8
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Internal/ManagedCallback.cs
  6. 46
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Util/CallbackOnDispose.cs

1
src/AddIns/Misc/Debugger/Debugger.Core/Project/Debugger.Core.csproj
Unescape View File

@ -266,6 +266,7 @@ @@ -266,6 +266,7 @@
<Compile Include="Src\Mono.Cecil\Mono.Cecil.Signatures\Var.cs" />
<Compile Include="Src\Mono.Cecil\Mono.Cecil\MethodCallingConvention.cs" />
<Compile Include="Src\Mono.Cecil\Mono.Cecil\ReflectionException.cs" />
<Compile Include="Src\Util\CallbackOnDispose.cs" />
<Compile Include="Src\Util\HighPrecisionTimer.cs" />
<Compile Include="Src\Values\ArrayDimension.cs" />
<Compile Include="Src\Values\ArrayDimensions.cs" />

3
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Control/Process-StateControl.cs
Unescape View File

@ -5,6 +5,7 @@ @@ -5,6 +5,7 @@
// <version>$Revision$</version>
// </file>
using ICSharpCode.NRefactory.Ast;
using System;
using System.Collections.Generic;
@ -16,6 +17,7 @@ namespace Debugger @@ -16,6 +17,7 @@ namespace Debugger
{
internal bool TerminateCommandIssued = false;
internal Queue<Breakpoint> BreakpointHitEventQueue = new Queue<Breakpoint>();
internal Dictionary<INode, Value> CachedExpressions = new Dictionary<INode, Value>();
#region Events
@ -99,6 +101,7 @@ namespace Debugger @@ -99,6 +101,7 @@ namespace Debugger
if (action == DebuggeeStateAction.Clear) {
if (debuggeeState == null) throw new DebuggerException("Debugee state already cleared");
debuggeeState = null;
this.CachedExpressions.Clear();
}
}

9
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Control/Process.cs
Unescape View File

@ -185,13 +185,16 @@ namespace Debugger @@ -185,13 +185,16 @@ namespace Debugger
}
}
public void TraceMessage(string message, params object[] args)
public void TraceVerboseMessage(string message, params object[] args)
{
TraceMessage(string.Format(message, args));
if (this.Options.Verbose)
TraceMessage(message, args);
}
public void TraceMessage(string message)
public void TraceMessage(string message, params object[] args)
{
if (args.Length > 0)
message = string.Format(message, args);
System.Diagnostics.Debug.WriteLine("Debugger:" + message);
debugger.OnDebuggerTraceMessage(new MessageEventArgs(this, message));
}

496
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Expressions/ExpressionEvaluator.cs
Unescape View File

@ -8,6 +8,7 @@ using ICSharpCode.NRefactory.PrettyPrinter; @@ -8,6 +8,7 @@ using ICSharpCode.NRefactory.PrettyPrinter;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
using Debugger.MetaData;
using ICSharpCode.NRefactory;
@ -18,7 +19,7 @@ namespace Debugger @@ -18,7 +19,7 @@ namespace Debugger
{
public class ExpressionEvaluator: NotImplementedAstVisitor
{
/// <summary> Evaluate given expression. If you expression tree already, use overloads of this method.</summary>
/// <summary> Evaluate given expression. If you have expression tree already, use overloads of this method.</summary>
/// <returns> Returned value or null for statements </returns>
public static Value Evaluate(string code, SupportedLanguage language, StackFrame context)
{
@ -45,29 +46,12 @@ namespace Debugger @@ -45,29 +46,12 @@ namespace Debugger
}
}
static Dictionary<AppDomain, Dictionary<string, Value>> expressionCache = new Dictionary<AppDomain, Dictionary<string, Value>>();
public static Value Evaluate(INode code, StackFrame context)
{
if (context == null) throw new ArgumentNullException("context");
if (context.IsInvalid) throw new DebuggerException("The context is no longer valid");
string codeAsText = code.PrettyPrint();
// Get value from cache if possible
if (expressionCache.ContainsKey(context.AppDomain) &&
expressionCache[context.AppDomain].ContainsKey(codeAsText)) {
Value cached = expressionCache[context.AppDomain][codeAsText];
if (!cached.IsInvalid) {
if (context.Process.Options.Verbose) {
context.Process.TraceMessage(string.Format("Cached: {0}", codeAsText));
}
return cached;
}
}
Value result;
DateTime start = Debugger.Util.HighPrecisionTimer.Now;
try {
result = (Value)code.AcceptVisitor(new ExpressionEvaluator(context), null);
} catch (GetValueException) {
@ -75,18 +59,6 @@ namespace Debugger @@ -75,18 +59,6 @@ namespace Debugger
} catch (NotImplementedException e) {
throw new GetValueException(code, "Language feature not implemented: " + e.Message);
}
DateTime end = Debugger.Util.HighPrecisionTimer.Now;
// Store value in cache
if (!expressionCache.ContainsKey(context.AppDomain)) {
expressionCache[context.AppDomain] = new Dictionary<string, Value>();
// TODO
}
// expressionCache[context.AppDomain][codeAsText] = result;
if (context.Process.Options.Verbose) {
context.Process.TraceMessage(string.Format("Evaluated: {0} ({1} ms)", code, (end - start).TotalMilliseconds));
}
return result;
}
@ -129,6 +101,34 @@ namespace Debugger @@ -129,6 +101,34 @@ namespace Debugger
}
}
void AddToCache(INode expression, Value value)
{
// Expressions are cleared then the process is resumed
context.Process.CachedExpressions[expression] = value;
}
bool TryGetCached(INode expression, out Value cached)
{
Value val;
if (context.Process.CachedExpressions.TryGetValue(expression, out val)) {
if (val == null || !val.IsInvalid) {
// context.Process.TraceMessage("Is cached: {0}", expression.PrettyPrint());
cached = val;
return true;
}
}
cached = null;
return false;
}
Value EvalAndPermRef(INode expression)
{
Value val = (Value)expression.AcceptVisitor(this, null);
if (val != null)
val = val.GetPermanentReference();
AddToCache(expression, val);
return val;
}
StackFrame context;
@ -141,256 +141,344 @@ namespace Debugger @@ -141,256 +141,344 @@ namespace Debugger
this.context = context;
}
public override object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)
IDisposable LogEval(INode expression)
{
Stopwatch watch = new Stopwatch();
watch.Start();
return new CallbackOnDispose(delegate {
if (!context.Process.CachedExpressions.ContainsKey(expression))
throw new DebuggerException("Result not added to cache");
watch.Stop();
context.Process.TraceMessage("Evaluated: {0} in {1} ms total", expression.PrettyPrint(), watch.ElapsedMilliseconds);
});
}
public override object VisitEmptyStatement(EmptyStatement emptyStatement, object data)
{
BinaryOperatorType op;
switch (assignmentExpression.Op) {
case AssignmentOperatorType.Assign: op = BinaryOperatorType.None; break;
case AssignmentOperatorType.Add: op = BinaryOperatorType.Add; break;
case AssignmentOperatorType.ConcatString: op = BinaryOperatorType.Concat; break;
case AssignmentOperatorType.Subtract: op = BinaryOperatorType.Subtract; break;
case AssignmentOperatorType.Multiply: op = BinaryOperatorType.Multiply; break;
case AssignmentOperatorType.Divide: op = BinaryOperatorType.Divide; break;
case AssignmentOperatorType.DivideInteger: op = BinaryOperatorType.DivideInteger; break;
case AssignmentOperatorType.ShiftLeft: op = BinaryOperatorType.ShiftLeft; break;
case AssignmentOperatorType.ShiftRight: op = BinaryOperatorType.ShiftRight; break;
case AssignmentOperatorType.ExclusiveOr: op = BinaryOperatorType.ExclusiveOr; break;
case AssignmentOperatorType.Modulus: op = BinaryOperatorType.Modulus; break;
case AssignmentOperatorType.BitwiseAnd: op = BinaryOperatorType.BitwiseAnd; break;
case AssignmentOperatorType.BitwiseOr: op = BinaryOperatorType.BitwiseOr; break;
case AssignmentOperatorType.Power: op = BinaryOperatorType.Power; break;
default: throw new GetValueException("Unknown operator " + assignmentExpression.Op);
using(LogEval(emptyStatement)) {
return null;
}
}
Value right;
if (op == BinaryOperatorType.None) {
right = (Value)assignmentExpression.Right.AcceptVisitor(this, null);
} else {
BinaryOperatorExpression binOpExpr = new BinaryOperatorExpression();
binOpExpr.Left = assignmentExpression.Left;
binOpExpr.Op = op;
binOpExpr.Right = assignmentExpression.Right;
right = (Value)VisitBinaryOperatorExpression(binOpExpr, null);
public override object VisitExpressionStatement(ExpressionStatement expressionStatement, object data)
{
using(LogEval(expressionStatement)) {
EvalAndPermRef(expressionStatement.Expression);
return null;
}
right = right.GetPermanentReference();
}
Value left = ((Value)assignmentExpression.Left.AcceptVisitor(this, null));
public override object VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data)
{
Value cached;
if (TryGetCached(parenthesizedExpression, out cached)) return cached;
using(LogEval(parenthesizedExpression)) {
Value res = EvalAndPermRef(parenthesizedExpression.Expression);
if (!left.IsReference && left.Type.FullName != right.Type.FullName) {
throw new GetValueException(string.Format("Type {0} expected, {1} seen", left.Type.FullName, right.Type.FullName));
AddToCache(parenthesizedExpression, res);
return res;
}
left.SetValue(right);
return right;
}
public override object VisitBlockStatement(BlockStatement blockStatement, object data)
{
foreach(INode statement in blockStatement.Children) {
statement.AcceptVisitor(this, null);
using(LogEval(blockStatement)) {
foreach(INode statement in blockStatement.Children) {
EvalAndPermRef(statement);
}
return null;
}
return null;
}
public override object VisitEmptyStatement(EmptyStatement emptyStatement, object data)
/// <remarks> We have to put that in cache as well otherwise expaning (a = b).Prop will reevalute </remarks>
public override object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)
{
return null;
}
Value cached;
if (TryGetCached(assignmentExpression, out cached)) return cached;
using(LogEval(assignmentExpression)) {
BinaryOperatorType op;
switch (assignmentExpression.Op) {
case AssignmentOperatorType.Assign: op = BinaryOperatorType.None; break;
case AssignmentOperatorType.Add: op = BinaryOperatorType.Add; break;
case AssignmentOperatorType.ConcatString: op = BinaryOperatorType.Concat; break;
case AssignmentOperatorType.Subtract: op = BinaryOperatorType.Subtract; break;
case AssignmentOperatorType.Multiply: op = BinaryOperatorType.Multiply; break;
case AssignmentOperatorType.Divide: op = BinaryOperatorType.Divide; break;
case AssignmentOperatorType.DivideInteger: op = BinaryOperatorType.DivideInteger; break;
case AssignmentOperatorType.ShiftLeft: op = BinaryOperatorType.ShiftLeft; break;
case AssignmentOperatorType.ShiftRight: op = BinaryOperatorType.ShiftRight; break;
case AssignmentOperatorType.ExclusiveOr: op = BinaryOperatorType.ExclusiveOr; break;
case AssignmentOperatorType.Modulus: op = BinaryOperatorType.Modulus; break;
case AssignmentOperatorType.BitwiseAnd: op = BinaryOperatorType.BitwiseAnd; break;
case AssignmentOperatorType.BitwiseOr: op = BinaryOperatorType.BitwiseOr; break;
case AssignmentOperatorType.Power: op = BinaryOperatorType.Power; break;
default: throw new GetValueException("Unknown operator " + assignmentExpression.Op);
}
public override object VisitExpressionStatement(ExpressionStatement expressionStatement, object data)
{
expressionStatement.Expression.AcceptVisitor(this, null);
return null;
Value right;
if (op == BinaryOperatorType.None) {
right = EvalAndPermRef(assignmentExpression.Right);
} else {
BinaryOperatorExpression binOpExpr = new BinaryOperatorExpression();
binOpExpr.Left = assignmentExpression.Left;
binOpExpr.Op = op;
binOpExpr.Right = assignmentExpression.Right;
right = (Value)VisitBinaryOperatorExpression(binOpExpr, null);
}
right = right.GetPermanentReference();
Value left = EvalAndPermRef(assignmentExpression.Left);
if (!left.IsReference && left.Type.FullName != right.Type.FullName) {
throw new GetValueException(string.Format("Type {0} expected, {1} seen", left.Type.FullName, right.Type.FullName));
}
left.SetValue(right);
AddToCache(assignmentExpression, right);
return right;
}
}
public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
{
string identifier = identifierExpression.Identifier;
if (identifier == "__exception") {
if (context.Thread.CurrentException != null) {
return context.Thread.CurrentException.Value;
} else {
throw new GetValueException("No current exception");
Value cached;
if (TryGetCached(identifierExpression, out cached)) return cached;
using(LogEval(identifierExpression)) {
string identifier = identifierExpression.Identifier;
Value result = null;
if (identifier == "__exception") {
if (context.Thread.CurrentException != null) {
result = context.Thread.CurrentException.Value;
} else {
throw new GetValueException("No current exception");
}
}
}
Value arg = context.GetArgumentValue(identifier);
if (arg != null) return arg;
result = result ?? context.GetArgumentValue(identifier);
Value local = context.GetLocalVariableValue(identifier);
if (local != null) return local;
result = result ?? context.GetLocalVariableValue(identifier);
if (!context.MethodInfo.IsStatic) {
Value member = context.GetThisValue().GetMemberValue(identifier);
if (member != null) return member;
} else {
MemberInfo memberInfo = context.MethodInfo.DeclaringType.GetMember(identifier);
if (memberInfo != null && memberInfo.IsStatic) {
return Value.GetMemberValue(null, memberInfo, null);
if (result == null) {
if (!context.MethodInfo.IsStatic) {
// Can be null
result = context.GetThisValue().GetMemberValue(identifier);
} else {
MemberInfo memberInfo = context.MethodInfo.DeclaringType.GetMember(identifier);
if (memberInfo != null && memberInfo.IsStatic) {
result = Value.GetMemberValue(null, memberInfo, null);
}
}
}
}
throw new GetValueException("Identifier \"" + identifier + "\" not found in this context");
if (result == null)
throw new GetValueException("Identifier \"" + identifier + "\" not found in this context");
AddToCache(identifierExpression, result);
return result;
}
}
public override object VisitIndexerExpression(IndexerExpression indexerExpression, object data)
{
List<Value> indexes = new List<Value>();
foreach(Expression indexExpr in indexerExpression.Indexes) {
Value indexValue = ((Value)indexExpr.AcceptVisitor(this, null)).GetPermanentReference();
indexes.Add(indexValue);
}
Value cached;
if (TryGetCached(indexerExpression, out cached)) return cached;
using(LogEval(indexerExpression)) {
List<Value> indexes = new List<Value>();
foreach(Expression indexExpr in indexerExpression.Indexes) {
Value indexValue = EvalAndPermRef(indexExpr);
indexes.Add(indexValue);
}
Value target = (Value)indexerExpression.TargetObject.AcceptVisitor(this, null);
Value target = EvalAndPermRef(indexerExpression.TargetObject);
if (target.Type.IsArray) {
List<int> intIndexes = new List<int>();
foreach(Value index in indexes) {
if (!index.Type.IsInteger) throw new GetValueException("Integer expected for indexer");
intIndexes.Add((int)index.PrimitiveValue);
if (target.Type.IsArray) {
List<int> intIndexes = new List<int>();
foreach(Value index in indexes) {
if (!index.Type.IsInteger) throw new GetValueException("Integer expected for indexer");
intIndexes.Add((int)index.PrimitiveValue);
}
return target.GetArrayElement(intIndexes.ToArray());
}
return target.GetArrayElement(intIndexes.ToArray());
}
if (target.Type.IsPrimitive && target.PrimitiveValue is string) {
if (indexes.Count == 1 && indexes[0].Type.IsInteger) {
int index = (int)indexes[0].PrimitiveValue;
return Eval.CreateValue(context.AppDomain, ((string)target.PrimitiveValue)[index]);
} else {
throw new GetValueException("Expected single integer index");
if (target.Type.IsPrimitive && target.PrimitiveValue is string) {
if (indexes.Count == 1 && indexes[0].Type.IsInteger) {
int index = (int)indexes[0].PrimitiveValue;
return Eval.CreateValue(context.AppDomain, ((string)target.PrimitiveValue)[index]);
} else {
throw new GetValueException("Expected single integer index");
}
}
}
PropertyInfo pi = target.Type.GetProperty("Item");
if (pi == null) throw new GetValueException("The object does not have an indexer property");
return target.GetPropertyValue(pi, indexes.ToArray());
PropertyInfo pi = target.Type.GetProperty("Item");
if (pi == null) throw new GetValueException("The object does not have an indexer property");
Value result = target.GetPropertyValue(pi, indexes.ToArray());
AddToCache(indexerExpression, result);
return result;
}
}
public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
Value target;
string methodName;
MemberReferenceExpression memberRef = invocationExpression.TargetObject as MemberReferenceExpression;
if (memberRef != null) {
target = ((Value)memberRef.TargetObject.AcceptVisitor(this, null)).GetPermanentReference();
methodName = memberRef.MemberName;
} else {
IdentifierExpression ident = invocationExpression.TargetObject as IdentifierExpression;
if (ident != null) {
target = context.GetThisValue();
methodName = ident.Identifier;
Value cached;
if (TryGetCached(invocationExpression, out cached)) return cached;
using(LogEval(invocationExpression)) {
Value target;
string methodName;
MemberReferenceExpression memberRef = invocationExpression.TargetObject as MemberReferenceExpression;
if (memberRef != null) {
target = EvalAndPermRef(memberRef.TargetObject);
methodName = memberRef.MemberName;
} else {
throw new GetValueException("Member reference expected for method invocation");
IdentifierExpression ident = invocationExpression.TargetObject as IdentifierExpression;
if (ident != null) {
target = context.GetThisValue();
methodName = ident.Identifier;
} else {
throw new GetValueException("Member reference expected for method invocation");
}
}
List<Value> args = new List<Value>();
foreach(Expression expr in invocationExpression.Arguments) {
args.Add(EvalAndPermRef(expr));
}
MethodInfo method = target.Type.GetMember(methodName, BindingFlags.Method | BindingFlags.IncludeSuperType) as MethodInfo;
if (method == null) {
throw new GetValueException("Method " + methodName + " not found");
}
Value result = target.InvokeMethod(method, args.ToArray());
AddToCache(invocationExpression, result);
return result;
}
List<Value> args = new List<Value>();
foreach(Expression expr in invocationExpression.Arguments) {
args.Add(((Value)expr.AcceptVisitor(this, null)).GetPermanentReference());
}
MethodInfo method = target.Type.GetMember(methodName, BindingFlags.Method | BindingFlags.IncludeSuperType) as MethodInfo;
if (method == null) {
throw new GetValueException("Method " + methodName + " not found");
}
return target.InvokeMethod(method, args.ToArray());
}
public override object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data)
{
Value target = (Value)memberReferenceExpression.TargetObject.AcceptVisitor(this, null);
Value member = target.GetMemberValue(memberReferenceExpression.MemberName);
if (member != null) {
Value cached;
if (TryGetCached(memberReferenceExpression, out cached)) return cached;
using(LogEval(memberReferenceExpression)) {
Value target = EvalAndPermRef(memberReferenceExpression.TargetObject);
Value member = target.GetMemberValue(memberReferenceExpression.MemberName);
if (member == null)
throw new GetValueException("Member \"" + memberReferenceExpression.MemberName + "\" not found");
AddToCache(memberReferenceExpression, member);
return member;
} else {
throw new GetValueException("Member \"" + memberReferenceExpression.MemberName + "\" not found");
}
}
public override object VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data)
{
return parenthesizedExpression.Expression.AcceptVisitor(this, null);
}
public override object VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data)
{
return Eval.CreateValue(context.AppDomain, primitiveExpression.Value);
Value cached;
if (TryGetCached(primitiveExpression, out cached)) return cached;
using(LogEval(primitiveExpression)){
Value result = Eval.CreateValue(context.AppDomain, primitiveExpression.Value);
AddToCache(primitiveExpression, result);
return result;
}
}
public override object VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data)
{
return context.GetThisValue();
Value cached;
if (TryGetCached(thisReferenceExpression, out cached)) return cached;
using(LogEval(thisReferenceExpression)) {
Value result = context.GetThisValue();
AddToCache(thisReferenceExpression, result);
return result;
}
}
public override object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data)
{
Value value = ((Value)unaryOperatorExpression.Expression.AcceptVisitor(this, null));
UnaryOperatorType op = unaryOperatorExpression.Op;
if (op == UnaryOperatorType.Dereference) {
if (!value.Type.IsPointer) throw new GetValueException("Target object is not a pointer");
return value.Dereference();
}
Value cached;
if (TryGetCached(unaryOperatorExpression, out cached)) return cached;
using(LogEval(unaryOperatorExpression)) {
Value value = EvalAndPermRef(unaryOperatorExpression.Expression);
UnaryOperatorType op = unaryOperatorExpression.Op;
if (op == UnaryOperatorType.Dereference) {
if (!value.Type.IsPointer) throw new GetValueException("Target object is not a pointer");
return value.Dereference();
}
if (!value.Type.IsPrimitive) throw new GetValueException("Primitive value expected");
if (!value.Type.IsPrimitive) throw new GetValueException("Primitive value expected");
object val = value.PrimitiveValue;
object val = value.PrimitiveValue;
object result = null;
object result = null;
// Bool operation
if (val is bool) {
bool a = Convert.ToBoolean(val);
switch (op) {
case UnaryOperatorType.Not: result = !a; break;
// Bool operation
if (val is bool) {
bool a = Convert.ToBoolean(val);
switch (op) {
case UnaryOperatorType.Not: result = !a; break;
}
}
}
// Float operation
if (val is double || val is float) {
double a = Convert.ToDouble(val);
switch (op) {
case UnaryOperatorType.Minus: result = -a; break;
case UnaryOperatorType.Plus: result = +a; break;
// Float operation
if (val is double || val is float) {
double a = Convert.ToDouble(val);
switch (op) {
case UnaryOperatorType.Minus: result = -a; break;
case UnaryOperatorType.Plus: result = +a; break;
}
}
}
// Integer operation
if (val is byte || val is sbyte || val is int || val is uint || val is long || val is ulong) {
long a = Convert.ToInt64(val);
switch (op) {
case UnaryOperatorType.Decrement: result = a - 1; break;
case UnaryOperatorType.Increment: result = a + 1; break;
case UnaryOperatorType.PostDecrement: result = a; break;
case UnaryOperatorType.PostIncrement: result = a; break;
case UnaryOperatorType.Minus: result = -a; break;
case UnaryOperatorType.Plus: result = a; break;
case UnaryOperatorType.BitNot: result = ~a; break;
}
switch (op) {
case UnaryOperatorType.Decrement:
case UnaryOperatorType.PostDecrement:
VisitAssignmentExpression(new AssignmentExpression(unaryOperatorExpression.Expression, AssignmentOperatorType.Subtract, new PrimitiveExpression(1)), null);
break;
case UnaryOperatorType.Increment:
case UnaryOperatorType.PostIncrement:
VisitAssignmentExpression(new AssignmentExpression(unaryOperatorExpression.Expression, AssignmentOperatorType.Add, new PrimitiveExpression(1)), null);
break;
// Integer operation
if (val is byte || val is sbyte || val is int || val is uint || val is long || val is ulong) {
long a = Convert.ToInt64(val);
switch (op) {
case UnaryOperatorType.Decrement: result = a - 1; break;
case UnaryOperatorType.Increment: result = a + 1; break;
case UnaryOperatorType.PostDecrement: result = a; break;
case UnaryOperatorType.PostIncrement: result = a; break;
case UnaryOperatorType.Minus: result = -a; break;
case UnaryOperatorType.Plus: result = a; break;
case UnaryOperatorType.BitNot: result = ~a; break;
}
switch (op) {
case UnaryOperatorType.Decrement:
case UnaryOperatorType.PostDecrement:
VisitAssignmentExpression(new AssignmentExpression(unaryOperatorExpression.Expression, AssignmentOperatorType.Subtract, new PrimitiveExpression(1)), null);
break;
case UnaryOperatorType.Increment:
case UnaryOperatorType.PostIncrement:
VisitAssignmentExpression(new AssignmentExpression(unaryOperatorExpression.Expression, AssignmentOperatorType.Add, new PrimitiveExpression(1)), null);
break;
}
}
}
if (result == null) throw new GetValueException("Unsuppored unary expression " + op);
if (result == null) throw new GetValueException("Unsuppored unary expression " + op);
Value res = Eval.CreateValue(context.AppDomain, result);
return Eval.CreateValue(context.AppDomain, result);
AddToCache(unaryOperatorExpression, res);
return res;
}
}
public override object VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data)
{
Value left = ((Value)binaryOperatorExpression.Left.AcceptVisitor(this, null)).GetPermanentReference();
Value right = ((Value)binaryOperatorExpression.Right.AcceptVisitor(this, null)).GetPermanentReference();
object result = VisitBinaryOperatorExpressionInternal(left, right, binaryOperatorExpression.Op);
// Conver long to int if possible
if (result is long && int.MinValue <= (long)result && (long)result <= int.MaxValue) result = (int)(long)result;
return Eval.CreateValue(context.AppDomain, result);
Value cached;
if (TryGetCached(binaryOperatorExpression, out cached)) return cached;
using(LogEval(binaryOperatorExpression)) {
Value left = EvalAndPermRef(binaryOperatorExpression.Left);
Value right = EvalAndPermRef(binaryOperatorExpression.Right);
object result = VisitBinaryOperatorExpressionInternal(left, right, binaryOperatorExpression.Op);
// Conver long to int if possible
if (result is long && int.MinValue <= (long)result && (long)result <= int.MaxValue) result = (int)(long)result;
Value res = Eval.CreateValue(context.AppDomain, result);
AddToCache(binaryOperatorExpression, res);
return res;
}
}
public object VisitBinaryOperatorExpressionInternal(Value leftValue, Value rightValue, BinaryOperatorType op)

8
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Internal/ManagedCallback.cs
Unescape View File

@ -240,14 +240,18 @@ namespace Debugger @@ -240,14 +240,18 @@ namespace Debugger
public void EvalException(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugEval corEval)
{
EnterCallback(PausedReason.EvalComplete, "EvalException", pThread);
Eval eval = process.ActiveEvals[corEval];
EnterCallback(PausedReason.EvalComplete, "EvalException: " + eval.Description, pThread);
HandleEvalComplete(pAppDomain, pThread, corEval, true);
}
public void EvalComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugEval corEval)
{
EnterCallback(PausedReason.EvalComplete, "EvalComplete", pThread);
Eval eval = process.ActiveEvals[corEval];
EnterCallback(PausedReason.EvalComplete, "EvalComplete: " + eval.Description, pThread);
HandleEvalComplete(pAppDomain, pThread, corEval, false);
}

46
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Util/CallbackOnDispose.cs
Unescape View File

@ -0,0 +1,46 @@ @@ -0,0 +1,46 @@
// <file>
// <copyright see="prj:///doc/copyright.txt"/>
// <license see="prj:///doc/license.txt"/>
// <owner name="Daniel Grunwald"/>
// <version>$Revision$</version>
// </file>
using System;
using System.Diagnostics;
using System.Threading;
namespace Debugger
{
/// <summary>
/// Invokes a callback when this class is disposed.
/// </summary>
sealed class CallbackOnDispose : IDisposable
{
Action callback;
public CallbackOnDispose(Action callback)
{
if (callback == null)
throw new ArgumentNullException("callback");
this.callback = callback;
}
public void Dispose()
{
Action action = Interlocked.Exchange(ref callback, null);
if (action != null) {
action();
#if DEBUG
GC.SuppressFinalize(this);
#endif
}
}
#if DEBUG
~CallbackOnDispose()
{
Debug.Fail("CallbackOnDispose was finalized without being disposed.");
}
#endif
}
}
Write Preview
Loading…
Cancel
Save