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

Port debugger libraries to use new NRefactory.

pull/191/merge
Eusebiu Marcu 15 years ago
parent
edd396a82c
commit
a0ca895498
9 changed files with 293 additions and 246 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. 2
      Debugger/Debugger.Core/Debugger.Core.csproj
  2. 186
      Debugger/Debugger.Core/NRefactory/Ast/ExpressionExtensionMethods.cs
  3. 333
      Debugger/Debugger.Core/NRefactory/Visitors/ExpressionEvaluator.cs
  4. 1
      Debugger/ILSpy.Debugger/AvalonEdit/IconBarMargin.cs
  5. 2
      Debugger/ILSpy.Debugger/Bookmarks/BookmarkManager.cs
  6. 6
      Debugger/ILSpy.Debugger/Models/TreeModel/ChildNodesOfObject.cs
  7. 1
      Debugger/ILSpy.Debugger/Models/TreeModel/StackFrameNode.cs
  8. 4
      Debugger/ILSpy.Debugger/Services/Debugger/DebuggerHelper.cs
  9. 4
      NRefactory/ICSharpCode.NRefactory/CSharp/Ast/Expressions/BinaryOperatorExpression.cs

2
Debugger/Debugger.Core/Debugger.Core.csproj
Unescape View File

@ -19,7 +19,7 @@ @@ -19,7 +19,7 @@
<FileAlignment>4096</FileAlignment>
<WarningLevel>4</WarningLevel>
<TreatWarningsAsErrors>false</TreatWarningsAsErrors>
<OutputPath>\bin</OutputPath>
<OutputPath>bin\Debug\</OutputPath>
<AllowUnsafeBlocks>True</AllowUnsafeBlocks>
<PublishUrl>http://localhost/Debugger.Core/</PublishUrl>
<Install>true</Install>

186
Debugger/Debugger.Core/NRefactory/Ast/ExpressionExtensionMethods.cs
Unescape View File

@ -3,6 +3,8 @@ @@ -3,6 +3,8 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using Debugger;
@ -149,9 +151,13 @@ namespace ICSharpCode.NRefactory.Ast @@ -149,9 +151,13 @@ namespace ICSharpCode.NRefactory.Ast
public static string PrettyPrint(this AstNode code)
{
if (code == null) return string.Empty;
CSharpOutputVisitor csOutVisitor = new CSharpOutputVisitor();
code.AcceptVisitor(csOutVisitor, null);
return csOutVisitor.Text;
using (var sw = new StringWriter())
{
OutputVisitor csOutVisitor = new OutputVisitor(sw, new CSharpFormattingPolicy());
code.AcceptVisitor(csOutVisitor, null);
return sw.ToString();
}
}
public static AstType GetTypeReference(this Type type)
@ -190,12 +196,21 @@ namespace ICSharpCode.NRefactory.Ast @@ -190,12 +196,21 @@ namespace ICSharpCode.NRefactory.Ast
if (type.DeclaringType != null) {
var outterRef = type.DeclaringType.GetTypeReference();
var innerRef = new InnerClassTypeReference(outterRef, name, genTypeRefs);
innerRef.PointerNestingLevel = pointerNest;
innerRef.RankSpecifier = arrayRanks.ToArray();
var innerRef = new ComposedType() {
PointerRank = pointerNest,
ArraySpecifiers = arrayRanks.ConvertAll(r => new ArraySpecifier(r)),
BaseType = new MemberType() {
Target = outterRef, MemberName = name, TypeArguments = genTypeRefs }
};
return innerRef.SetStaticType((DebugType)type);
} else {
return new TypeReference(name, pointerNest, arrayRanks.ToArray(), genTypeRefs).SetStaticType((DebugType)type);
return (new ComposedType() {
PointerRank = pointerNest,
ArraySpecifiers = arrayRanks.ConvertAll(r => new ArraySpecifier(r)),
BaseType = new SimpleType() {
Identifier = name,
TypeArguments = genTypeRefs }}).SetStaticType((DebugType)type);
}
}
@ -204,61 +219,75 @@ namespace ICSharpCode.NRefactory.Ast @@ -204,61 +219,75 @@ namespace ICSharpCode.NRefactory.Ast
/// Dotted names are split into separate nodes.
/// It does not normalize generic arguments.
/// </summary>
static SimpleType NormalizeTypeReference(this AstNode expr)
static AstType NormalizeTypeReference(this AstNode expr)
{
if (expr is IdentifierExpression) {
return new SimpleType() {
return new SimpleType() {
Identifier = ((IdentifierExpression)expr).Identifier,
TypeArguments = ((IdentifierExpression)expr).TypeArguments};
} else if (expr is MemberReferenceExpression) {
var outter = NormalizeTypeReference(((MemberReferenceExpression)expr).Target);
return new InnerClassTypeReference(
outter,
((MemberReferenceExpression)expr).MemberName,
((MemberReferenceExpression)expr).TypeArguments
);
return new MemberType() { Target = outter,
MemberName = ((MemberReferenceExpression)expr).MemberName,
TypeArguments = ((MemberReferenceExpression)expr).TypeArguments };
} else if (expr is TypeReferenceExpression) {
return NormalizeTypeReference(((TypeReferenceExpression)expr).TypeReference);
} else if (expr is InnerClassTypeReference) { // Frist - it is also TypeReference
InnerClassTypeReference typeRef = (InnerClassTypeReference)expr;
string[] names = typeRef.Type.Split('.');
var newRef = NormalizeTypeReference(typeRef.BaseType);
foreach(string name in names) {
newRef = new InnerClassTypeReference(newRef, name, new List<TypeReference>());
}
newRef.GenericTypes.AddRange(typeRef.GenericTypes);
newRef.PointerNestingLevel = typeRef.PointerNestingLevel;
newRef.RankSpecifier = typeRef.RankSpecifier;
return newRef;
} else if (expr is TypeReference) {
var typeRef = (TypeReference)expr;
string[] names = typeRef.Type.Split('.');
if (names.Length == 1)
return typeRef;
TypeReference newRef = null;
return NormalizeTypeReference(((TypeReferenceExpression)expr).Type);
} else if (expr is ComposedType) { // Frist - it is also TypeReference
var typeRef = (ComposedType)expr;
string[] names = null;
if (typeRef.BaseType is SimpleType)
names = (((SimpleType)typeRef.BaseType)).Identifier.Split('.');
else
names = (((MemberType)typeRef.BaseType)).MemberName.Split('.');
var newRef = NormalizeTypeReference(typeRef.BaseType) as ComposedType;
foreach(string name in names) {
if (newRef == null) {
newRef = new TypeReference(name, new List<TypeReference>());
} else {
newRef = new TypeReference(newRef, name, new List<TypeReference>());
}
newRef = new ComposedType() {
BaseType = new SimpleType() { Identifier = name, TypeArguments = new List<AstType>() }
};
}
newRef.GenericTypes.AddRange(typeRef.GenericTypes);
newRef.PointerNestingLevel = typeRef.PointerNestingLevel;
newRef.RankSpecifier = typeRef.RankSpecifier;
//(((MemberType)newRef).TypeArguments as List<AstType>).AddRange(typeRef.TypeArguments);
newRef.PointerRank = typeRef.PointerRank;
newRef.ArraySpecifiers = typeRef.ArraySpecifiers;
return newRef;
} else {
}
// else if (expr is SimpleType) {
// var typeRef = (SimpleType)expr;
// string[] names = typeRef.Identifier.Split('.');
// if (names.Length == 1)
// return typeRef;
// SimpleType newRef = null;
// foreach(string name in names) {
// if (newRef == null) {
// newRef = new SimpleType() { Identifier = name, TypeArguments = new List<AstType>() };
// } else {
// newRef = new MemberType() { Target = newRef, MemberName = name, TypeArguments = new List<AstType>() };
// }
// }
// ((List<AstType>)newRef.TypeArguments).AddRange(typeRef.TypeArguments);
// newRef.PointerNestingLevel = typeRef.PointerNestingLevel;
// newRef.RankSpecifier = typeRef.RankSpecifier;
// return newRef;
// }
else {
throw new EvaluateException(expr, "Type expected. {0} seen.", expr.GetType().FullName);
}
}
static string GetNameWithArgCounts(SimpleType typeRef)
static string GetNameWithArgCounts(AstType typeRef)
{
string name = typeRef.Type;
if (typeRef.GenericTypes.Count > 0)
name += "`" + typeRef.GenericTypes.Count.ToString();
if (typeRef is InnerClassTypeReference) {
return GetNameWithArgCounts(((InnerClassTypeReference)typeRef).BaseType) + "." + name;
string name = string.Empty;
if (typeRef is SimpleType)
{
name = ((SimpleType)typeRef).Identifier;
if (((SimpleType)typeRef).TypeArguments.Count() > 0)
name += "`" + ((SimpleType)typeRef).TypeArguments.Count().ToString();
}
if (typeRef is MemberType) {
name = ((MemberType)typeRef).MemberName;
return GetNameWithArgCounts(((MemberType)typeRef).Target) + "." + name;
} else {
return name;
}
@ -266,24 +295,26 @@ namespace ICSharpCode.NRefactory.Ast @@ -266,24 +295,26 @@ namespace ICSharpCode.NRefactory.Ast
public static DebugType ResolveType(this AstNode expr, Debugger.AppDomain appDomain)
{
if (expr is TypeReference && expr.GetStaticType() != null)
if (expr is AstType && expr.GetStaticType() != null)
return expr.GetStaticType();
if (expr is TypeReferenceExpression && ((TypeReferenceExpression)expr).TypeReference.GetStaticType() != null)
return ((TypeReferenceExpression)expr).TypeReference.GetStaticType();
if (expr is TypeReferenceExpression && ((TypeReferenceExpression)expr).Type.GetStaticType() != null)
return ((TypeReferenceExpression)expr).Type.GetStaticType();
appDomain.Process.TraceMessage("Resolving {0}", expr.PrettyPrint());
TypeReference typeRef = NormalizeTypeReference(expr);
var typeRef = NormalizeTypeReference(expr);
List<TypeReference> genTypeRefs;
if (typeRef is InnerClassTypeReference) {
genTypeRefs = ((InnerClassTypeReference)typeRef).CombineToNormalTypeReference().GenericTypes;
List<AstType> genTypeRefs = null;
if (typeRef is MemberType) {
//FIXME genTypeRefs = ((MemberType)typeRef).CombineToNormalTypeReference().TypeArguments as List<AstType>;
} else {
genTypeRefs = typeRef.GenericTypes;
if (typeRef is SimpleType) {
genTypeRefs = ((SimpleType)typeRef).TypeArguments as List<AstType>;
}
}
List<DebugType> genArgs = new List<DebugType>();
foreach(TypeReference genTypeRef in genTypeRefs) {
foreach(var genTypeRef in genTypeRefs) {
genArgs.Add(ResolveType(genTypeRef, appDomain));
}
@ -294,37 +325,46 @@ namespace ICSharpCode.NRefactory.Ast @@ -294,37 +325,46 @@ namespace ICSharpCode.NRefactory.Ast
/// For performance this is separate method.
/// 'genArgs' should hold type for each generic parameter in 'typeRef'.
/// </summary>
static DebugType ResolveTypeInternal(SimpleType typeRef, DebugType[] genArgs, Debugger.AppDomain appDomain)
static DebugType ResolveTypeInternal(AstType typeRef, DebugType[] genArgs, Debugger.AppDomain appDomain)
{
DebugType type = null;
// Try to construct non-nested type
// If there are generic types up in the tree, it must be nested type
if (genArgs.Length == typeRef.GenericTypes.Count) {
string name = GetNameWithArgCounts(typeRef);
type = DebugType.CreateFromNameOrNull(appDomain, name, null, genArgs);
if (typeRef is SimpleType) {
// Try to construct non-nested type
// If there are generic types up in the tree, it must be nested type
var simple = (SimpleType)typeRef;
if (genArgs.Length == simple.TypeArguments.Count()) {
string name = GetNameWithArgCounts(simple);
type = DebugType.CreateFromNameOrNull(appDomain, name, null, genArgs);
}
}
// Try to construct nested type
if (type == null && typeRef is InnerClassTypeReference) {
if (type == null && typeRef is MemberType) {
var member = (MemberType)typeRef;
DebugType[] outterGenArgs = genArgs;
// Do not pass our generic arguments to outter type
Array.Resize(ref outterGenArgs, genArgs.Length - typeRef.GenericTypes.Count);
Array.Resize(ref outterGenArgs, genArgs.Length - member.TypeArguments.Count());
DebugType outter = ResolveTypeInternal(((InnerClassTypeReference)typeRef).BaseType, outterGenArgs, appDomain);
string nestedName = typeRef.GenericTypes.Count == 0 ? typeRef.Type : typeRef.Type + "`" + typeRef.GenericTypes.Count;
DebugType outter = ResolveTypeInternal(member.Target, outterGenArgs, appDomain);
string nestedName = member.TypeArguments.Count() == 0 ?
member.MemberName : member.MemberName + "`" + member.TypeArguments.Count();
type = DebugType.CreateFromNameOrNull(appDomain, nestedName, outter, genArgs);
}
if (type == null)
throw new GetValueException("Can not resolve " + typeRef.PrettyPrint());
for(int i = 0; i < typeRef.PointerNestingLevel; i++) {
type = (DebugType)type.MakePointerType();
}
if (typeRef.RankSpecifier != null) {
for(int i = typeRef.RankSpecifier.Length - 1; i >= 0; i--) {
type = (DebugType)type.MakeArrayType(typeRef.RankSpecifier[i] + 1);
if (typeRef is ComposedType) {
for(int i = 0; i < ((ComposedType)typeRef).PointerRank; i++) {
type = (DebugType)type.MakePointerType();
}
if (((ComposedType)typeRef).ArraySpecifiers != null) {
var enumerator = ((ComposedType)typeRef).ArraySpecifiers.Reverse().GetEnumerator();
while (enumerator.MoveNext()) {
type = (DebugType)type.MakeArrayType(enumerator.Current.Dimensions + 1);
}
}
}
return type;

333
Debugger/Debugger.Core/NRefactory/Visitors/ExpressionEvaluator.cs
Unescape View File

@ -4,6 +4,7 @@ @@ -4,6 +4,7 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
@ -60,15 +61,21 @@ namespace ICSharpCode.NRefactory.Visitors @@ -60,15 +61,21 @@ namespace ICSharpCode.NRefactory.Visitors
public static AstNode Parse(string code, SupportedLanguage language)
{
SnippetParser parser = new SnippetParser(language);
AstNode astRoot = parser.Parse(code);
if (parser.Errors.Count > 0) {
throw new GetValueException(parser.Errors.ErrorOutput);
}
if (parser.SnippetType != SnippetType.Expression && parser.SnippetType != SnippetType.Statements) {
throw new GetValueException("Code must be expression or statement");
switch (language) {
case SupportedLanguage.CSharp:
var parser = new CSharpParser();
using (var textReader = new StringReader(code)) {
AstNode astRoot = parser.ParseExpression(textReader);
if (parser.HasErrors) {
throw new GetValueException("Parser errors");
}
return astRoot;
}
break;
default:
throw new ArgumentException("Unsuported language");
}
return astRoot;
}
/// <summary> Evaluate given expression. If you have expression tree already, use overloads of this method.</summary>
@ -106,16 +113,20 @@ namespace ICSharpCode.NRefactory.Visitors @@ -106,16 +113,20 @@ namespace ICSharpCode.NRefactory.Visitors
/// </summary>
public static Expression ParseExpression(string code, SupportedLanguage language)
{
SnippetParser parser = new SnippetParser(language);
AstNode astRoot = parser.Parse(code);
if (parser.Errors.Count > 0) {
throw new GetValueException(parser.Errors.ErrorOutput);
}
Expression astExpression = astRoot as Expression;
if (astExpression == null) {
throw new GetValueException("Code must be expression");
switch (language) {
case SupportedLanguage.CSharp:
var parser = new CSharpParser();
using (var textReader = new StringReader(code)) {
AstNode astRoot = parser.ParseExpression(textReader);
if (parser.HasErrors) {
throw new GetValueException("Parser errors");
}
return astRoot as Expression;
}
default:
throw new ArgumentException("Unsuported language");
}
return astExpression;
}
public static string FormatValue(Value val)
@ -279,21 +290,17 @@ namespace ICSharpCode.NRefactory.Visitors @@ -279,21 +290,17 @@ namespace ICSharpCode.NRefactory.Visitors
{
BinaryOperatorType op;
switch (assignmentExpression.Operator) {
//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.Operator);
case AssignmentOperatorType.Add: op = BinaryOperatorType.Add; break;
case AssignmentOperatorType.Subtract: op = BinaryOperatorType.Subtract; break;
case AssignmentOperatorType.Multiply: op = BinaryOperatorType.Multiply; break;
case AssignmentOperatorType.Divide: op = BinaryOperatorType.Divide; 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;
default: throw new GetValueException("Unknown operator " + assignmentExpression.Operator);
}
TypedValue right;
@ -343,7 +350,7 @@ namespace ICSharpCode.NRefactory.Visitors @@ -343,7 +350,7 @@ namespace ICSharpCode.NRefactory.Visitors
public object VisitCastExpression(CastExpression castExpression, object data)
{
TypedValue val = Evaluate(castExpression.Expression);
DebugType castTo = castExpression.ResolveType(context.AppDomain).CastTo();
DebugType castTo = null;// FIXME castExpression.CastTo().ResolveType(context.AppDomain);
if (castTo.IsPrimitive && val.Type.IsPrimitive && castTo != val.Type) {
object oldVal = val.PrimitiveValue;
object newVal;
@ -491,10 +498,10 @@ namespace ICSharpCode.NRefactory.Visitors @@ -491,10 +498,10 @@ namespace ICSharpCode.NRefactory.Visitors
public object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data)
{
if (arrayCreateExpression.Initializer.RankSpecifier[0] != 0)
if (arrayCreateExpression.AdditionalArraySpecifiers.Count() != 0)
throw new EvaluateException(arrayCreateExpression, "Multi-dimensional arrays are not suppored");
DebugType type = arrayCreateExpression.CreateType.ResolveType(context.AppDomain);
DebugType type = arrayCreateExpression.Type.ResolveType(context.AppDomain);
int length = 0;
if (arrayCreateExpression.Arguments.Count() == 1) {
length = EvaluateAsInt(arrayCreateExpression.Arguments.First());
@ -592,9 +599,9 @@ namespace ICSharpCode.NRefactory.Visitors @@ -592,9 +599,9 @@ namespace ICSharpCode.NRefactory.Visitors
TypedValue newValue = null;
try {
if (op == UnaryOperatorType.Decrement || op == UnaryOperatorType.PostDecrement)
newValue = (TypedValue)VisitAssignmentExpression(new AssignmentExpression(unaryOperatorExpression.Expression, AssignmentOperatorType.Subtract), null);
newValue = (TypedValue)VisitAssignmentExpression(new AssignmentExpression() { Right = unaryOperatorExpression.Expression, Operator = AssignmentOperatorType.Subtract }, null);
if (op == UnaryOperatorType.Increment || op == UnaryOperatorType.PostIncrement)
newValue = (TypedValue)VisitAssignmentExpression(new AssignmentExpression(unaryOperatorExpression.Expression, AssignmentOperatorType.Add), null);
newValue = (TypedValue)VisitAssignmentExpression(new AssignmentExpression(){ Right = unaryOperatorExpression.Expression, Operator = AssignmentOperatorType.Add }, null);
} catch (EvaluateException e) {
throw new EvaluateException(unaryOperatorExpression, e.Message);
}
@ -644,7 +651,7 @@ namespace ICSharpCode.NRefactory.Visitors @@ -644,7 +651,7 @@ namespace ICSharpCode.NRefactory.Visitors
}
}
}
throw new EvaluateException(unaryOperatorExpression, "Can not use the unary operator {0} on type {1}", op.ToString(), value.Type.FullName);
}
@ -658,57 +665,57 @@ namespace ICSharpCode.NRefactory.Visitors @@ -658,57 +665,57 @@ namespace ICSharpCode.NRefactory.Visitors
if (argType == typeof(bool)) {
bool a = (bool)val;
switch (op) {
case UnaryOperatorType.Not: return !a;
case UnaryOperatorType.Not: return !a;
}
}
if (argType == typeof(float)) {
float a = (float)val;
switch (op) {
case UnaryOperatorType.Minus: return -a;
case UnaryOperatorType.Plus: return +a;
case UnaryOperatorType.Minus: return -a;
case UnaryOperatorType.Plus: return +a;
}
}
if (argType == typeof(double)) {
double a = (double)val;
switch (op) {
case UnaryOperatorType.Minus: return -a;
case UnaryOperatorType.Plus: return +a;
case UnaryOperatorType.Minus: return -a;
case UnaryOperatorType.Plus: return +a;
}
}
if (argType == typeof(int)) {
int a = (int)val;
switch (op) {
case UnaryOperatorType.Minus: return -a;
case UnaryOperatorType.Plus: return +a;
case UnaryOperatorType.BitNot: return ~a;
case UnaryOperatorType.Minus: return -a;
case UnaryOperatorType.Plus: return +a;
case UnaryOperatorType.BitNot: return ~a;
}
}
if (argType == typeof(uint)) {
uint a = (uint)val;
switch (op) {
case UnaryOperatorType.Plus: return +a;
case UnaryOperatorType.BitNot: return ~a;
case UnaryOperatorType.Plus: return +a;
case UnaryOperatorType.BitNot: return ~a;
}
}
if (argType == typeof(long)) {
long a = (long)val;
switch (op) {
case UnaryOperatorType.Minus: return -a;
case UnaryOperatorType.Plus: return +a;
case UnaryOperatorType.BitNot: return ~a;
case UnaryOperatorType.Minus: return -a;
case UnaryOperatorType.Plus: return +a;
case UnaryOperatorType.BitNot: return ~a;
}
}
if (argType == typeof(ulong)) {
ulong a = (ulong)val;
switch (op) {
case UnaryOperatorType.Plus: return +a;
case UnaryOperatorType.BitNot: return ~a;
case UnaryOperatorType.Plus: return +a;
case UnaryOperatorType.BitNot: return ~a;
}
}
}
@ -793,8 +800,8 @@ namespace ICSharpCode.NRefactory.Visitors @@ -793,8 +800,8 @@ namespace ICSharpCode.NRefactory.Visitors
// void operator +(ulong x, long y);
// float operator +(float x, float y);
// double operator +(double x, double y);
//
// &, |, ^, &&, ||
//
// &, |, ^, &&, ||
// ==, !=
// bool operator &(bool x, bool y);
@ -838,9 +845,9 @@ namespace ICSharpCode.NRefactory.Visitors @@ -838,9 +845,9 @@ namespace ICSharpCode.NRefactory.Visitors
string a = (string)left;
string b = (string)right;
switch (op) {
case BinaryOperatorType.Equality: return a == b;
case BinaryOperatorType.InEquality: return a != b;
case BinaryOperatorType.Add: return a + b;
case BinaryOperatorType.Equality: return a == b;
case BinaryOperatorType.InEquality: return a != b;
case BinaryOperatorType.Add: return a + b;
}
}
@ -848,13 +855,13 @@ namespace ICSharpCode.NRefactory.Visitors @@ -848,13 +855,13 @@ namespace ICSharpCode.NRefactory.Visitors
bool a = (bool)left;
bool b = (bool)right;
switch (op) {
case BinaryOperatorType.Equality: return a == b;
case BinaryOperatorType.InEquality: return a != b;
case BinaryOperatorType.ExclusiveOr: return a ^ b;
case BinaryOperatorType.BitwiseAnd: return a & b;
case BinaryOperatorType.BitwiseOr: return a | b;
case BinaryOperatorType.ConditionalAnd: return a && b;
case BinaryOperatorType.ConditionalOr: return a || b;
case BinaryOperatorType.Equality: return a == b;
case BinaryOperatorType.InEquality: return a != b;
case BinaryOperatorType.ExclusiveOr: return a ^ b;
case BinaryOperatorType.BitwiseAnd: return a & b;
case BinaryOperatorType.BitwiseOr: return a | b;
case BinaryOperatorType.ConditionalAnd: return a && b;
case BinaryOperatorType.ConditionalOr: return a || b;
}
}
@ -862,18 +869,18 @@ namespace ICSharpCode.NRefactory.Visitors @@ -862,18 +869,18 @@ namespace ICSharpCode.NRefactory.Visitors
float a = (float)left;
float b = (float)right;
switch (op) {
case BinaryOperatorType.GreaterThan: return a > b;
case BinaryOperatorType.GreaterThanOrEqual: return a >= b;
case BinaryOperatorType.Equality: return a == b;
case BinaryOperatorType.InEquality: return a != b;
case BinaryOperatorType.LessThan: return a < b;
case BinaryOperatorType.LessThanOrEqual: return a <= b;
case BinaryOperatorType.Add: return a + b;
case BinaryOperatorType.Subtract: return a - b;
case BinaryOperatorType.Multiply: return a * b;
case BinaryOperatorType.Divide: return a / b;
case BinaryOperatorType.Modulus: return a % b;
case BinaryOperatorType.GreaterThan: return a > b;
case BinaryOperatorType.GreaterThanOrEqual: return a >= b;
case BinaryOperatorType.Equality: return a == b;
case BinaryOperatorType.InEquality: return a != b;
case BinaryOperatorType.LessThan: return a < b;
case BinaryOperatorType.LessThanOrEqual: return a <= b;
case BinaryOperatorType.Add: return a + b;
case BinaryOperatorType.Subtract: return a - b;
case BinaryOperatorType.Multiply: return a * b;
case BinaryOperatorType.Divide: return a / b;
case BinaryOperatorType.Modulus: return a % b;
}
}
@ -881,129 +888,129 @@ namespace ICSharpCode.NRefactory.Visitors @@ -881,129 +888,129 @@ namespace ICSharpCode.NRefactory.Visitors
double a = (double)left;
double b = (double)right;
switch (op) {
case BinaryOperatorType.GreaterThan: return a > b;
case BinaryOperatorType.GreaterThanOrEqual: return a >= b;
case BinaryOperatorType.Equality: return a == b;
case BinaryOperatorType.InEquality: return a != b;
case BinaryOperatorType.LessThan: return a < b;
case BinaryOperatorType.LessThanOrEqual: return a <= b;
case BinaryOperatorType.Add: return a + b;
case BinaryOperatorType.Subtract: return a - b;
case BinaryOperatorType.Multiply: return a * b;
case BinaryOperatorType.Divide: return a / b;
case BinaryOperatorType.Modulus: return a % b;
case BinaryOperatorType.GreaterThan: return a > b;
case BinaryOperatorType.GreaterThanOrEqual: return a >= b;
case BinaryOperatorType.Equality: return a == b;
case BinaryOperatorType.InEquality: return a != b;
case BinaryOperatorType.LessThan: return a < b;
case BinaryOperatorType.LessThanOrEqual: return a <= b;
case BinaryOperatorType.Add: return a + b;
case BinaryOperatorType.Subtract: return a - b;
case BinaryOperatorType.Multiply: return a * b;
case BinaryOperatorType.Divide: return a / b;
case BinaryOperatorType.Modulus: return a % b;
}
}
if (argTypes == typeof(int)) {
switch (op) {
case BinaryOperatorType.ShiftLeft: return (int)left << (int)right;
case BinaryOperatorType.ShiftRight: return (int)left >> (int)right;
case BinaryOperatorType.ShiftLeft: return (int)left << (int)right;
case BinaryOperatorType.ShiftRight: return (int)left >> (int)right;
}
int a = (int)left;
int b = (int)right;
switch (op) {
case BinaryOperatorType.BitwiseAnd: return a & b;
case BinaryOperatorType.BitwiseOr: return a | b;
case BinaryOperatorType.ExclusiveOr: return a ^ b;
case BinaryOperatorType.GreaterThan: return a > b;
case BinaryOperatorType.GreaterThanOrEqual: return a >= b;
case BinaryOperatorType.Equality: return a == b;
case BinaryOperatorType.InEquality: return a != b;
case BinaryOperatorType.LessThan: return a < b;
case BinaryOperatorType.LessThanOrEqual: return a <= b;
case BinaryOperatorType.Add: return a + b;
case BinaryOperatorType.Subtract: return a - b;
case BinaryOperatorType.Multiply: return a * b;
case BinaryOperatorType.Divide: return a / b;
case BinaryOperatorType.Modulus: return a % b;
case BinaryOperatorType.BitwiseAnd: return a & b;
case BinaryOperatorType.BitwiseOr: return a | b;
case BinaryOperatorType.ExclusiveOr: return a ^ b;
case BinaryOperatorType.GreaterThan: return a > b;
case BinaryOperatorType.GreaterThanOrEqual: return a >= b;
case BinaryOperatorType.Equality: return a == b;
case BinaryOperatorType.InEquality: return a != b;
case BinaryOperatorType.LessThan: return a < b;
case BinaryOperatorType.LessThanOrEqual: return a <= b;
case BinaryOperatorType.Add: return a + b;
case BinaryOperatorType.Subtract: return a - b;
case BinaryOperatorType.Multiply: return a * b;
case BinaryOperatorType.Divide: return a / b;
case BinaryOperatorType.Modulus: return a % b;
}
}
if (argTypes == typeof(uint)) {
switch (op) {
case BinaryOperatorType.ShiftLeft: return (uint)left << (int)right;
case BinaryOperatorType.ShiftRight: return (uint)left >> (int)right;
case BinaryOperatorType.ShiftLeft: return (uint)left << (int)right;
case BinaryOperatorType.ShiftRight: return (uint)left >> (int)right;
}
uint a = (uint)left;
uint b = (uint)right;
switch (op) {
case BinaryOperatorType.BitwiseAnd: return a & b;
case BinaryOperatorType.BitwiseOr: return a | b;
case BinaryOperatorType.ExclusiveOr: return a ^ b;
case BinaryOperatorType.GreaterThan: return a > b;
case BinaryOperatorType.GreaterThanOrEqual: return a >= b;
case BinaryOperatorType.Equality: return a == b;
case BinaryOperatorType.InEquality: return a != b;
case BinaryOperatorType.LessThan: return a < b;
case BinaryOperatorType.LessThanOrEqual: return a <= b;
case BinaryOperatorType.Add: return a + b;
case BinaryOperatorType.Subtract: return a - b;
case BinaryOperatorType.Multiply: return a * b;
case BinaryOperatorType.Divide: return a / b;
case BinaryOperatorType.Modulus: return a % b;
case BinaryOperatorType.BitwiseAnd: return a & b;
case BinaryOperatorType.BitwiseOr: return a | b;
case BinaryOperatorType.ExclusiveOr: return a ^ b;
case BinaryOperatorType.GreaterThan: return a > b;
case BinaryOperatorType.GreaterThanOrEqual: return a >= b;
case BinaryOperatorType.Equality: return a == b;
case BinaryOperatorType.InEquality: return a != b;
case BinaryOperatorType.LessThan: return a < b;
case BinaryOperatorType.LessThanOrEqual: return a <= b;
case BinaryOperatorType.Add: return a + b;
case BinaryOperatorType.Subtract: return a - b;
case BinaryOperatorType.Multiply: return a * b;
case BinaryOperatorType.Divide: return a / b;
case BinaryOperatorType.Modulus: return a % b;
}
}
if (argTypes == typeof(long)) {
switch (op) {
case BinaryOperatorType.ShiftLeft: return (long)left << (int)right;
case BinaryOperatorType.ShiftRight: return (long)left >> (int)right;
case BinaryOperatorType.ShiftLeft: return (long)left << (int)right;
case BinaryOperatorType.ShiftRight: return (long)left >> (int)right;
}
long a = (long)left;
long b = (long)right;
switch (op) {
case BinaryOperatorType.BitwiseAnd: return a & b;
case BinaryOperatorType.BitwiseOr: return a | b;
case BinaryOperatorType.ExclusiveOr: return a ^ b;
case BinaryOperatorType.GreaterThan: return a > b;
case BinaryOperatorType.GreaterThanOrEqual: return a >= b;
case BinaryOperatorType.Equality: return a == b;
case BinaryOperatorType.InEquality: return a != b;
case BinaryOperatorType.LessThan: return a < b;
case BinaryOperatorType.LessThanOrEqual: return a <= b;
case BinaryOperatorType.Add: return a + b;
case BinaryOperatorType.Subtract: return a - b;
case BinaryOperatorType.Multiply: return a * b;
case BinaryOperatorType.Divide: return a / b;
case BinaryOperatorType.Modulus: return a % b;
case BinaryOperatorType.BitwiseAnd: return a & b;
case BinaryOperatorType.BitwiseOr: return a | b;
case BinaryOperatorType.ExclusiveOr: return a ^ b;
case BinaryOperatorType.GreaterThan: return a > b;
case BinaryOperatorType.GreaterThanOrEqual: return a >= b;
case BinaryOperatorType.Equality: return a == b;
case BinaryOperatorType.InEquality: return a != b;
case BinaryOperatorType.LessThan: return a < b;
case BinaryOperatorType.LessThanOrEqual: return a <= b;
case BinaryOperatorType.Add: return a + b;
case BinaryOperatorType.Subtract: return a - b;
case BinaryOperatorType.Multiply: return a * b;
case BinaryOperatorType.Divide: return a / b;
case BinaryOperatorType.Modulus: return a % b;
}
}
if (argTypes == typeof(ulong)) {
switch (op) {
case BinaryOperatorType.ShiftLeft: return (ulong)left << (int)right;
case BinaryOperatorType.ShiftRight: return (ulong)left >> (int)right;
case BinaryOperatorType.ShiftLeft: return (ulong)left << (int)right;
case BinaryOperatorType.ShiftRight: return (ulong)left >> (int)right;
}
ulong a = (ulong)left;
ulong b = (ulong)right;
switch (op) {
case BinaryOperatorType.BitwiseAnd: return a & b;
case BinaryOperatorType.BitwiseOr: return a | b;
case BinaryOperatorType.ExclusiveOr: return a ^ b;
case BinaryOperatorType.GreaterThan: return a > b;
case BinaryOperatorType.GreaterThanOrEqual: return a >= b;
case BinaryOperatorType.Equality: return a == b;
case BinaryOperatorType.InEquality: return a != b;
case BinaryOperatorType.LessThan: return a < b;
case BinaryOperatorType.LessThanOrEqual: return a <= b;
case BinaryOperatorType.Add: return a + b;
case BinaryOperatorType.Subtract: return a - b;
case BinaryOperatorType.Multiply: return a * b;
case BinaryOperatorType.Divide: return a / b;
case BinaryOperatorType.Modulus: return a % b;
case BinaryOperatorType.BitwiseAnd: return a & b;
case BinaryOperatorType.BitwiseOr: return a | b;
case BinaryOperatorType.ExclusiveOr: return a ^ b;
case BinaryOperatorType.GreaterThan: return a > b;
case BinaryOperatorType.GreaterThanOrEqual: return a >= b;
case BinaryOperatorType.Equality: return a == b;
case BinaryOperatorType.InEquality: return a != b;
case BinaryOperatorType.LessThan: return a < b;
case BinaryOperatorType.LessThanOrEqual: return a <= b;
case BinaryOperatorType.Add: return a + b;
case BinaryOperatorType.Subtract: return a - b;
case BinaryOperatorType.Multiply: return a * b;
case BinaryOperatorType.Divide: return a / b;
case BinaryOperatorType.Modulus: return a % b;
}
}
return null;
}
}

1
Debugger/ILSpy.Debugger/AvalonEdit/IconBarMargin.cs
Unescape View File

@ -25,6 +25,7 @@ using System.Windows.Media; @@ -25,6 +25,7 @@ using System.Windows.Media;
using ICSharpCode.AvalonEdit.Editing;
using ICSharpCode.AvalonEdit.Rendering;
using ICSharpCode.AvalonEdit.Utils;
using ICSharpCode.Decompiler.Disassembler;
using ILSpy.Debugger.Bookmarks;
using ILSpy.Debugger.Services;
using Mono.Cecil;

2
Debugger/ILSpy.Debugger/Bookmarks/BookmarkManager.cs
Unescape View File

@ -119,7 +119,7 @@ namespace ILSpy.Debugger.Bookmarks @@ -119,7 +119,7 @@ namespace ILSpy.Debugger.Bookmarks
}
}
// no bookmark at that line: create a new bookmark
BookmarkManager.AddMark(bookmarkFactory(new AstLocation(0, line)));
BookmarkManager.AddMark(bookmarkFactory(new AstLocation(line, 0)));
}
public static event BookmarkEventHandler Removed;

6
Debugger/ILSpy.Debugger/Models/TreeModel/ChildNodesOfObject.cs
Unescape View File

@ -97,11 +97,7 @@ namespace ILSpy.Debugger.Models.TreeModel @@ -97,11 +97,7 @@ namespace ILSpy.Debugger.Models.TreeModel
public static IEnumerable<TreeNode> LazyGetItemsOfIList(Expression targetObject)
{
// This is needed for expanding IEnumerable<T>
targetObject = new CastExpression(
new TypeReference(typeof(IList).FullName),
targetObject,
CastType.Cast
);
targetObject = new CastExpression() { Expression = targetObject, Type = new SimpleType() { Identifier = typeof(IList).FullName } };
int count = 0;
GetValueException error = null;
try {

1
Debugger/ILSpy.Debugger/Models/TreeModel/StackFrameNode.cs
Unescape View File

@ -4,6 +4,7 @@ using System.Collections.Generic; @@ -4,6 +4,7 @@ using System.Collections.Generic;
using Debugger;
using Debugger.MetaData;
using ICSharpCode.NRefactory.Ast;
using ICSharpCode.NRefactory.CSharp;
namespace ILSpy.Debugger.Models.TreeModel
{

4
Debugger/ILSpy.Debugger/Services/Debugger/DebuggerHelper.cs
Unescape View File

@ -27,8 +27,8 @@ namespace ILSpy.Debugger.Services.Debugger @@ -27,8 +27,8 @@ namespace ILSpy.Debugger.Services.Debugger
listType = DebugType.CreateFromType(itemType.AppDomain, typeof(System.Collections.Generic.List<>), itemType);
var iEnumerableType = DebugType.CreateFromType(itemType.AppDomain, typeof(IEnumerable<>), itemType);
// explicitely cast the variable to IEnumerable<T>, where T is itemType
Expression iEnumerableVariableExplicitCast = new CastExpression(iEnumerableType.GetTypeReference() , iEnumerableVariable, CastType.Cast);
return new ObjectCreateExpression(listType.GetTypeReference(), iEnumerableVariableExplicitCast.ToList());
Expression iEnumerableVariableExplicitCast = new CastExpression { Expression = iEnumerableVariable , Type = iEnumerableType.GetTypeReference() };
return new ObjectCreateExpression() { Type = listType.GetTypeReference(), Arguments = iEnumerableVariableExplicitCast.ToList() };
}
/// <summary>

4
NRefactory/ICSharpCode.NRefactory/CSharp/Ast/Expressions/BinaryOperatorExpression.cs
Unescape View File

@ -167,6 +167,8 @@ namespace ICSharpCode.NRefactory.CSharp @@ -167,6 +167,8 @@ namespace ICSharpCode.NRefactory.CSharp
ShiftRight,
/// <summary>left ?? right</summary>
NullCoalescing
NullCoalescing,
None
}
}

Write Preview
Loading…
Cancel
Save