public ObjectValue GetExpressionValue(EvaluationContext ctx, string exp)
{
try {
ValueReference var = ctx.Evaluator.Evaluate(ctx, exp);
if (var != null)
{
return(var.CreateObjectValue(ctx.Options));
}
else
{
return(ObjectValue.CreateUnknown(exp));
}
}
catch (ImplicitEvaluationDisabledException) {
return(ObjectValue.CreateImplicitNotSupported(ctx.ExpressionValueSource, new ObjectPath(exp), "", ObjectValueFlags.None));
}
catch (NotSupportedExpressionException ex) {
return(ObjectValue.CreateNotSupported(ctx.ExpressionValueSource, new ObjectPath(exp), ex.Message, "", ObjectValueFlags.None));
}
catch (EvaluatorException ex) {
return(ObjectValue.CreateError(ctx.ExpressionValueSource, new ObjectPath(exp), "", ex.Message, ObjectValueFlags.None));
}
catch (Exception ex) {
ctx.WriteDebuggerError(ex);
return(ObjectValue.CreateUnknown(exp));
}
}
ObjectValue CreateObjectValue(ISymbolValue v, IExpression originalExpression, ObjectPath pathOpt, EvaluationOptions evalOptions, IDBacktraceSymbol symbolOpt = null)
{
if (v != null)
{
try
{
return(v.Accept(new ObjectValueSynthVisitor(this)
{
evalOptions = evalOptions, OriginalExpression = originalExpression, Path = pathOpt
}));
}
catch (NotImplementedException) { }
}
if (symbolOpt != null)
{
return(ObjectValue.CreatePrimitive(this, pathOpt, symbolOpt.TypeName, new Mono.Debugging.Backend.EvaluationResult(symbolOpt.Value), ObjectValueFlags.Variable));
}
return(ObjectValue.CreateError(this, pathOpt, "", "Couldn't evaluate expression " + (originalExpression != null ? originalExpression.ToString() : ""), ObjectValueFlags.Error));
}
public static ObjectValue Create(object obj, ObjectPath path)
{
var sessionOptions = DebuggingService.GetUserOptions();
var options = sessionOptions.EvaluationOptions;
var context = new CSharpInteractiveEvaluationContext(options);
context.Adapter = objectValueAdapter;
context.Evaluator = new CSharpInteractiveExpressionEvaluator();
var source = new CSharpInteractiveObjectValueSource(path.Join("."), obj, context);
try {
// Cannot update top level value types from the REPL so mark the top level objects as read-only.
var flags = ObjectValueFlags.ReadOnly;
ObjectValue value = objectValueAdapter.CreateObjectValue(context, source, path, obj, flags);
AttachStackFrame(value, sessionOptions);
return(value);
} catch (Exception ex) {
return(ObjectValue.CreateError(null, path, string.Empty, ex.Message, ObjectValueFlags.None));
}
}
public ObjectValue GetValue(ObjectPath path, EvaluationOptions options)
{
string shortName = name;
var indexOfSpace = name.IndexOf(' ');
if (indexOfSpace != -1) //Remove " [TypeName]" from variable name
{
shortName = name.Remove(indexOfSpace);
}
if (type == null)
{
return(ObjectValue.CreateError(null, new ObjectPath(shortName), "", val, ObjectValueFlags.None));
}
if (val == "null")
{
return(ObjectValue.CreateNullObject(this, shortName, type, parentVariablesReference > 0 ? ObjectValueFlags.None : ObjectValueFlags.ReadOnly));
}
if (variablesReference == 0) //This is some kind of primitive...
{
return(ObjectValue.CreatePrimitive(this, new ObjectPath(shortName), type, new EvaluationResult(val), parentVariablesReference > 0 ? ObjectValueFlags.None : ObjectValueFlags.ReadOnly));
}
return(ObjectValue.CreateObject(this, new ObjectPath(shortName), type, new EvaluationResult(val), parentVariablesReference > 0 ? ObjectValueFlags.None : ObjectValueFlags.ReadOnly, null));
}
public virtual ObjectValue[] GetObjectValueChildren(EvaluationContext ctx, IObjectSource objectSource, object type, object obj, int firstItemIndex, int count, bool dereferenceProxy)
{
if (IsArray(ctx, obj))
{
ArrayElementGroup agroup = new ArrayElementGroup(ctx, CreateArrayAdaptor(ctx, obj));
return(agroup.GetChildren(ctx.Options));
}
if (IsPrimitive(ctx, obj))
{
return(new ObjectValue[0]);
}
bool showRawView = false;
// If there is a proxy, it has to show the members of the proxy
object proxy = obj;
if (dereferenceProxy)
{
proxy = GetProxyObject(ctx, obj);
if (proxy != obj)
{
type = GetValueType(ctx, proxy);
showRawView = true;
}
}
TypeDisplayData tdata = GetTypeDisplayData(ctx, type);
bool groupPrivateMembers = ctx.Options.GroupPrivateMembers && (ctx.Options.GroupUserPrivateMembers || IsExternalType(ctx, type));
List <ObjectValue> values = new List <ObjectValue> ();
BindingFlags flattenFlag = ctx.Options.FlattenHierarchy ? (BindingFlags)0 : BindingFlags.DeclaredOnly;
BindingFlags nonNonPublicFlag = groupPrivateMembers || showRawView ? (BindingFlags)0 : BindingFlags.NonPublic;
BindingFlags staticFlag = ctx.Options.GroupStaticMembers ? (BindingFlags)0 : BindingFlags.Static;
BindingFlags access = BindingFlags.Public | BindingFlags.Instance | flattenFlag | nonNonPublicFlag | staticFlag;
// Load all members to a list before creating the object values,
// to avoid problems with objects being invalidated due to evaluations in the target,
List <ValueReference> list = new List <ValueReference> ();
list.AddRange(GetMembersSorted(ctx, objectSource, type, proxy, access));
object tdataType = type;
foreach (ValueReference val in list)
{
try {
object decType = val.DeclaringType;
if (decType != null && decType != tdataType)
{
tdataType = decType;
tdata = GetTypeDisplayData(ctx, decType);
}
DebuggerBrowsableState state = tdata.GetMemberBrowsableState(val.Name);
if (state == DebuggerBrowsableState.Never)
{
continue;
}
if (state == DebuggerBrowsableState.RootHidden && dereferenceProxy)
{
object ob = val.Value;
if (ob != null)
{
values.Clear();
values.AddRange(GetObjectValueChildren(ctx, val, ob, -1, -1));
showRawView = true;
break;
}
}
else
{
ObjectValue oval = val.CreateObjectValue(true);
values.Add(oval);
}
}
catch (Exception ex) {
ctx.WriteDebuggerError(ex);
values.Add(ObjectValue.CreateError(null, new ObjectPath(val.Name), GetDisplayTypeName(GetTypeName(ctx, val.Type)), ex.Message, val.Flags));
}
}
if (showRawView)
{
values.Add(RawViewSource.CreateRawView(ctx, objectSource, obj));
}
else
{
if (IsArray(ctx, proxy))
{
ICollectionAdaptor col = CreateArrayAdaptor(ctx, proxy);
ArrayElementGroup agroup = new ArrayElementGroup(ctx, col);
ObjectValue val = ObjectValue.CreateObject(null, new ObjectPath("Raw View"), "", "", ObjectValueFlags.ReadOnly, values.ToArray());
values = new List <ObjectValue> ();
values.Add(val);
values.AddRange(agroup.GetChildren(ctx.Options));
}
else
{
if (ctx.Options.GroupStaticMembers && HasMembers(ctx, type, proxy, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | flattenFlag))
{
access = BindingFlags.Static | BindingFlags.Public | flattenFlag | nonNonPublicFlag;
values.Add(FilteredMembersSource.CreateStaticsNode(ctx, objectSource, type, proxy, access));
}
if (groupPrivateMembers && HasMembers(ctx, type, proxy, BindingFlags.Instance | BindingFlags.NonPublic | flattenFlag | staticFlag))
{
values.Add(FilteredMembersSource.CreateNonPublicsNode(ctx, objectSource, type, proxy, BindingFlags.Instance | BindingFlags.NonPublic | flattenFlag | staticFlag));
}
if (!ctx.Options.FlattenHierarchy)
{
object baseType = GetBaseType(ctx, type, false);
if (baseType != null)
{
values.Insert(0, BaseTypeViewSource.CreateBaseTypeView(ctx, objectSource, baseType, proxy));
}
}
}
}
return(values.ToArray());
}
