public ObjectValue[] GetLocalVariables(int frameIndex, EvaluationOptions options) { List<ObjectValue> values = new List<ObjectValue>(); if (Engine.Symbols.ScopeLocalSymbols == null) return values.ToArray(); for (uint i = 0; i < Engine.Symbols.ScopeLocalSymbols.Count; i++) { if (Engine.Symbols.ScopeLocalSymbols.Symbols[i].Parent != null) continue; string name = Engine.Symbols.ScopeLocalSymbols.Symbols[i].Name; string typename = Engine.Symbols.ScopeLocalSymbols.Symbols[i].TypeName; string val = Engine.Symbols.ScopeLocalSymbols.Symbols[i].TextValue; ulong offset = Engine.Symbols.ScopeLocalSymbols.Symbols[i].Offset; DEW.DebugScopedSymbol parentSymbol = Engine.Symbols.ScopeLocalSymbols.Symbols[i].Parent; ObjectValue ov = symbolResolver.Resolve(offset, name, typename, val, parentSymbol); if (ov == null) { ObjectValueFlags flags = ObjectValueFlags.Variable; ov = ObjectValue.CreatePrimitive(this, new ObjectPath(name), typename, new EvaluationResult(val), flags); } if (ov != null) values.Add(ov); } return values.ToArray(); }
public object CallMethod (string name, object[] parameters, out object[] outArgs, EvaluationOptions options) { object[] tempOutArgs = null; var result = MtaThread.Run (() => source.CallMethod (name, parameters, out tempOutArgs, options)); outArgs = tempOutArgs; return result; }
public ObjectValue[] GetChildren (ObjectPath path, int index, int count, EvaluationOptions options) { EvaluationContext cctx = ctx.WithOptions (options); var names = new ObjectValueNameTracker (cctx); object tdataType = null; TypeDisplayData tdata = null; List<ObjectValue> list = new List<ObjectValue> (); foreach (ValueReference val in cctx.Adapter.GetMembersSorted (cctx, objectSource, type, obj, bindingFlags)) { object decType = val.DeclaringType; if (decType != null && decType != tdataType) { tdataType = decType; tdata = cctx.Adapter.GetTypeDisplayData (cctx, decType); } DebuggerBrowsableState state = tdata.GetMemberBrowsableState (val.Name); if (state == DebuggerBrowsableState.Never) continue; ObjectValue oval = val.CreateObjectValue (options); names.FixName (val, oval); list.Add (oval); } if ((bindingFlags & BindingFlags.NonPublic) == 0) { BindingFlags newFlags = bindingFlags | BindingFlags.NonPublic; newFlags &= ~BindingFlags.Public; list.Add (CreateNonPublicsNode (cctx, objectSource, type, obj, newFlags)); } return list.ToArray (); }
public SoftEvaluationContext(SoftDebuggerSession session, StackFrame frame, DC.EvaluationOptions options) : base(options) { Frame = frame; Thread = frame.Thread; Domain = Thread.Domain; string method = frame.Method.Name; if (frame.Method.DeclaringType != null) { method = frame.Method.DeclaringType.FullName + "." + method; } var location = new DC.SourceLocation(method, frame.FileName, frame.LineNumber, frame.ColumnNumber); string language; if (frame.Method != null) { language = frame.IsNativeTransition ? "Transition" : "Managed"; } else { language = "Native"; } Evaluator = session.GetEvaluator(new DC.StackFrame(frame.ILOffset, location, language, session.IsExternalCode(frame), true)); Adapter = session.Adaptor; this.session = session; stackVersion = session.StackVersion; sourceAvailable = !string.IsNullOrEmpty(frame.FileName) && System.IO.File.Exists(frame.FileName); }
public ObjectValue[] GetAllLocals(int frameIndex, EvaluationOptions options) { List<ObjectValue> locals = new List<ObjectValue> (); locals.AddRange (GetParameters (frameIndex, options)); locals.AddRange (GetLocalVariables (frameIndex, options)); return locals.ToArray (); }
public ObjectValue[] GetParameters(int frameIndex, EvaluationOptions options) { List<ObjectValue> values = new List<ObjectValue>(); SelectFrame(frameIndex); return values.ToArray(); }
public override ExceptionInfo GetException(int frameIndex, EvaluationOptions options) { ObjectValue val = CreateExceptionObject(exceptionRecord); ExceptionInfo result = new ExceptionInfo(val); return result; }
public ObjectValue[] GetExpressionValues(int frameIndex, string[] expressions, EvaluationOptions options) { List<ObjectValue> values = new List<ObjectValue>(); SelectFrame(frameIndex); foreach (string exp in expressions) values.Add(CreateVarObject(exp)); return values.ToArray(); }
public EvaluationContext WithOptions (EvaluationOptions options) { if (options == null || Options == options) return this; EvaluationContext clone = Clone (); clone.Options = options; return clone; }
public void SetMemberValue (string name, object value, EvaluationOptions options) { EvaluationContext localContext = ctx.WithOptions (options); object type = localContext.Adapter.GetValueType (localContext, targetObject); ValueReference val = localContext.Adapter.GetMember (localContext, source, type, targetObject, name); if (val == null) throw new EvaluatorException ("Member '{0}' not found", name); val.Value = localContext.Adapter.FromRawValue (localContext, value); }
public ObjectValue[] GetLocalVariables (int frameIndex, EvaluationOptions options) { List<ObjectValue> values = new List<ObjectValue> (); SelectFrame (frameIndex); GdbCommandResult res = session.RunCommand ("-stack-list-locals", "0"); foreach (ResultData data in res.GetObject ("locals")) values.Add (CreateVarObject (data.GetValue ("name"))); return values.ToArray (); }
public ObjectValue CreateObjectValue (bool withTimeout, EvaluationOptions options) { if (!CanEvaluate (options)) return DC.ObjectValue.CreateImplicitNotSupported (this, new ObjectPath (Name), ctx.Adapter.GetTypeName (GetContext (options), Type), Flags); if (withTimeout) { return ctx.Adapter.CreateObjectValueAsync (Name, Flags, delegate { return CreateObjectValue (options); }); } else return CreateObjectValue (options); }
public object GetMemberValue(string name, EvaluationOptions options) { var localContext = ctx.WithOptions (options); var type = localContext.Adapter.GetValueType (localContext, targetObject); var val = localContext.Adapter.GetMember (localContext, source, type, targetObject, name); if (val == null) throw new EvaluatorException ("Member '{0}' not found", name); return localContext.Adapter.ToRawValue (localContext, val, val.Value); }
public override ValueReference GetChild (string name, EvaluationOptions options) { string newNs = namspace + "." + name; var ctx = GetContext (options); var type = ctx.Adapter.GetType (ctx, newNs); if (type != null) return new TypeValueReference (ctx, type); return new NamespaceValueReference (ctx, newNs); }
public object CallMethod (string name, object[] parameters, EvaluationOptions options) { EvaluationContext localContext = ctx.WithOptions (options); object[] argValues = new object [parameters.Length]; object[] argTypes = new object [parameters.Length]; for (int n=0; n<argValues.Length; n++) { argValues[n] = localContext.Adapter.FromRawValue (localContext, parameters[n]); argTypes[n] = localContext.Adapter.GetValueType (localContext, argValues[n]); } object type = localContext.Adapter.GetValueType (localContext, targetObject); object res = localContext.Adapter.RuntimeInvoke (localContext, type, targetObject, name, argTypes, argValues); return localContext.Adapter.ToRawValue (localContext, null, res); }
public ObjectValue[] GetAllLocals(int frameIndex, EvaluationOptions options) { session.RunCommand (true, "vars"); List<ObjectValue> locals = new List<ObjectValue> (); lock (syncLock) { foreach (string varName in session.lastResult.vars) { ObjectValue val; ObjectValueFlags flags = ObjectValueFlags.Variable; val = ObjectValue.CreatePrimitive (this, new ObjectPath (varName), "dummyInt", new EvaluationResult ("test_val"), flags); val.Name = varName; locals.Add (val); } } return locals.ToArray (); }
public ObjectValue[] GetChildren(ObjectPath path, int index, int count, EvaluationOptions options) { List<ObjectValue> children = new List<ObjectValue>(); session.SelectThread(threadId); if (Engine.Symbols.ScopeLocalSymbols == null) return children.ToArray(); DEW.DebugScopedSymbol parent = null; for (uint i = 0; i < Engine.Symbols.ScopeLocalSymbols.Symbols.Length; i++) { DEW.DebugScopedSymbol symbol = Engine.Symbols.ScopeLocalSymbols.Symbols[i]; if (symbol.Name == path.LastName) { parent = symbol; break; } } if (parent == null || parent.ChildrenCount == 0) return children.ToArray(); for (uint i = 0; i < parent.ChildrenCount; i++) { DEW.DebugScopedSymbol child = parent.Children[i]; string name = child.Name; string typename = child.TypeName; string val = child.TextValue; ulong offset = child.Offset; ObjectValue ov = symbolResolver.Resolve(offset, name, typename, val, child.Parent); if (ov == null) { ObjectValueFlags flags = ObjectValueFlags.Variable; ov = ObjectValue.CreatePrimitive(this, new ObjectPath(name), typename, new EvaluationResult(val), flags); } if (ov != null) children.Add(ov); } return children.ToArray(); }
public ObjectValue[] GetChildren (ObjectPath path, int index, int count, EvaluationOptions options) { var node = cacheRoot [path]; if(node == null) return Backtrace.GetChildren(path, index, count, options); ObjectValue[] children; var t = node.NodeType; if (t is ArrayType) children = GetArrayChildren (node, path, index, count, options); else if (t is ClassType || t is StructType) children = GetClassInstanceChildren (node, path, options); else children = new ObjectValue[0]; return children; }
public virtual ObjectValue[] GetAllLocals(int frameIndex, EvaluationOptions options) { var locals = new List<ObjectValue> (); var excObj = GetExceptionInstance (frameIndex, options); if (excObj != null) locals.Insert (0, excObj); locals.AddRange (GetLocalVariables (frameIndex, options)); locals.AddRange (GetParameters (frameIndex, options)); locals.Sort ((v1, v2) => StringComparer.InvariantCulture.Compare (v1.Name, v2.Name)); var thisObj = GetThisReference (frameIndex, options); if (thisObj != null) locals.Insert (0, thisObj); return locals.ToArray (); }
public virtual ObjectValue[] GetLocalVariables (int frameIndex, EvaluationOptions options) { FrameInfo frame = GetFrameInfo (frameIndex, options, false); List<ObjectValue> list = new List<ObjectValue> (); if (frame == null) { ObjectValue val = Adaptor.CreateObjectValueAsync ("Local Variables", ObjectValueFlags.EvaluatingGroup, delegate { frame = GetFrameInfo (frameIndex, options, true); foreach (ValueReference var in frame.LocalVariables) list.Add (var.CreateObjectValue (false, options)); return ObjectValue.CreateArray (null, new ObjectPath ("Local Variables"), "", list.Count, ObjectValueFlags.EvaluatingGroup, list.ToArray ()); }); return new ObjectValue [] { val }; } foreach (ValueReference var in frame.LocalVariables) list.Add (var.CreateObjectValue (true, options)); return list.ToArray (); }
public virtual ObjectValue[] GetParameters (int frameIndex, EvaluationOptions options) { List<ObjectValue> vars = new List<ObjectValue> (); FrameInfo frame = GetFrameInfo (frameIndex, options, false); if (frame == null) { ObjectValue val = Adaptor.CreateObjectValueAsync ("Parameters", ObjectValueFlags.EvaluatingGroup, delegate { frame = GetFrameInfo (frameIndex, options, true); foreach (ValueReference var in frame.Parameters) vars.Add (var.CreateObjectValue (false, options)); return ObjectValue.CreateArray (null, new ObjectPath ("Parameters"), "", vars.Count, ObjectValueFlags.EvaluatingGroup, vars.ToArray ()); }); return new ObjectValue [] { val }; } foreach (ValueReference var in frame.Parameters) vars.Add (var.CreateObjectValue (true, options)); return vars.ToArray (); }
public SoftEvaluationContext(SoftDebuggerSession session, StackFrame frame, DC.EvaluationOptions options) : base(options) { Frame = frame; Thread = frame.Thread; string method = frame.Method.Name; if (frame.Method.DeclaringType != null) { method = frame.Method.DeclaringType.FullName + "." + method; } var location = new DC.SourceLocation(method, frame.FileName, frame.LineNumber); var lang = frame.Method != null? "Managed" : "Native"; Evaluator = session.GetResolver(new DC.StackFrame(frame.ILOffset, location, lang, session.IsExternalCode(frame), true)); Adapter = session.Adaptor; this.session = session; this.stackVersion = session.StackVersion; }
public ObjectValue[] GetChildren(ObjectPath path, int index, int count, EvaluationOptions options) { List<ObjectValue> children = new List<ObjectValue> (); session.SelectThread (threadId); return children.ToArray(); /* DDebugCommandResult res = session.RunCommand("-var-list-children", "2", path.Join(".")); ResultData cdata = res.GetObject ("children"); // The response may not contain the "children" list at all. if (cdata == null) return children.ToArray (); if (index == -1) { index = 0; count = cdata.Count; } for (int n=index; n<cdata.Count && n<index+count; n++) { ResultData data = cdata.GetObject (n); ResultData child = data.GetObject ("child"); string name = child.GetValue ("exp"); if (name.Length > 0 && char.IsNumber (name [0])) name = "[" + name + "]"; // C++ structures may contain typeless children named // "public", "private" and "protected". if (child.GetValue("type") == null) { ObjectPath childPath = new ObjectPath (child.GetValue ("name").Split ('.')); ObjectValue[] subchildren = GetChildren (childPath, -1, -1, options); children.AddRange(subchildren); } else { ObjectValue val = CreateObjectValue (name, child); children.Add (val); } } return children.ToArray (); */ }
public bool HasChildren (ObjectPath path, EvaluationOptions options) { EvaluationContext cctx = ctx.WithOptions (options); TypeDisplayData tdata = null; object tdataType = null; foreach (ValueReference val in cctx.Adapter.GetMembersSorted (cctx, objectSource, type, obj, bindingFlags)) { object decType = val.DeclaringType; if (decType != null && decType != tdataType) { tdataType = decType; tdata = cctx.Adapter.GetTypeDisplayData (cctx, decType); } DebuggerBrowsableState state = tdata.GetMemberBrowsableState (val.Name); if (state == DebuggerBrowsableState.Never) continue; return true; } return false; }
public ObjectValue[] GetChildren(ObjectPath path, int index, int count, EvaluationOptions options) { List<ObjectValue> children = new List<ObjectValue>(); session.SelectThread(threadId); string expression = path.Join("."); if (expression.Trim().Length == 0) return children.ToArray(); List<DebugScopedSymbol> childSymbols = this.session.SymbolResolver.GetChildSymbols(expression); if (childSymbols.Count == 0) return children.ToArray(); for (int i = 0; i < childSymbols.Count; i++) { DebugScopedSymbol child = childSymbols[i]; ObjectValue ov = CreateObjectValue(child); children.Add(ov); } return children.ToArray(); }
public ObjectValue GetExpressionValue(string expression, EvaluationOptions options) { if (!hasDebugInfo) return ObjectValue.CreateUnknown (expression); if (options.UseExternalTypeResolver) expression = ResolveExpression (expression); var values = sourceBacktrace.GetExpressionValues (index, new [] { expression }, options); ObjectValue.ConnectCallbacks (this, values); return values [0]; }
public ExceptionInfo GetException(EvaluationOptions options) { var value = sourceBacktrace.GetException (index, options); if (value != null) value.ConnectCallback (this); return value; }
public void SetRawValue (ObjectPath path, object value, EvaluationOptions options) { throw new System.NotImplementedException (); }
void IRawObject.Connect(DebuggerSession session, EvaluationOptions options) { this.options = options; source = session.WrapDebuggerObject(source); }
public virtual string GetFullStackFrameText(EvaluationOptions options) { using (var cts = new CancellationTokenSource(options.MemberEvaluationTimeout)) return(GetFullStackFrameTextAsync(options, false, cts.Token).GetAwaiter().GetResult()); }
/// <summary> /// Sets the raw value of this object /// </summary> /// <param name='value'> /// The value /// </param> /// <param name='options'> /// The evaluation options /// </param> /// <remarks> /// The provided value can be a primitive type, a RawValue object or a RawValueArray object. /// </remarks> public void SetRawValue(object value, EvaluationOptions options) { source.SetRawValue(path, value, options); }
public ObjectValue[] GetExpressionValues(string[] expressions, EvaluationOptions options) { if (!hasDebugInfo) { var vals = new ObjectValue [expressions.Length]; for (int n = 0; n < expressions.Length; n++) vals[n] = ObjectValue.CreateUnknown (expressions[n]); return vals; } if (options.UseExternalTypeResolver) { var resolved = new string [expressions.Length]; for (int n = 0; n < expressions.Length; n++) resolved[n] = ResolveExpression (expressions[n]); expressions = resolved; } var values = sourceBacktrace.GetExpressionValues (index, expressions, options); ObjectValue.ConnectCallbacks (this, values); return values; }
public ObjectValue GetThisReference(EvaluationOptions options) { if (!hasDebugInfo) return null; var value = sourceBacktrace.GetThisReference (index, options); if (value != null) ObjectValue.ConnectCallbacks (this, value); return value; }
async Task <string> GetFullStackFrameTextAsync(EvaluationOptions options, bool doAsync, CancellationToken cancellationToken) { // If MethodName starts with "[", then it's something like [ExternalCode] if (SourceLocation.MethodName.StartsWith("[", StringComparison.Ordinal)) { return(SourceLocation.MethodName); } options = options.Clone(); if (options.StackFrameFormat.ParameterValues) { options.AllowMethodEvaluation = true; options.AllowToStringCalls = true; options.AllowTargetInvoke = true; } else { options.AllowMethodEvaluation = false; options.AllowToStringCalls = false; options.AllowTargetInvoke = false; } // Cache the method parameters. Only refresh the method params iff the cached args do not // already have parameter values. Once we have parameter values, we never have to // refresh the cached parameters because we can just omit the parameter values when // constructing the display string. if (parameters == null || (options.StackFrameFormat.ParameterValues && !haveParameterValues)) { haveParameterValues = options.StackFrameFormat.ParameterValues; parameters = GetParameters(options); } var methodNameBuilder = new StringBuilder(); if (options.StackFrameFormat.Module && !string.IsNullOrEmpty(FullModuleName)) { methodNameBuilder.Append(Path.GetFileName(FullModuleName)); methodNameBuilder.Append('!'); } methodNameBuilder.Append(SourceLocation.MethodName); if (options.StackFrameFormat.ParameterTypes || options.StackFrameFormat.ParameterNames || options.StackFrameFormat.ParameterValues) { methodNameBuilder.Append('('); for (int n = 0; n < parameters.Length; n++) { if (parameters[n].IsEvaluating) { var tcs = new TaskCompletionSource <bool> (); EventHandler updated = (s, e) => { tcs.TrySetResult(true); }; parameters[n].ValueChanged += updated; try { using (var registration = cancellationToken.Register(() => tcs.TrySetCanceled())) { if (parameters[n].IsEvaluating) { if (doAsync) { await tcs.Task.ConfigureAwait(false); } else { tcs.Task.Wait(cancellationToken); } } } } finally { parameters[n].ValueChanged -= updated; } } if (n > 0) { methodNameBuilder.Append(", "); } if (options.StackFrameFormat.ParameterTypes) { methodNameBuilder.Append(parameters[n].TypeName); if (options.StackFrameFormat.ParameterNames) { methodNameBuilder.Append(' '); } } if (options.StackFrameFormat.ParameterNames) { methodNameBuilder.Append(parameters[n].Name); } if (options.StackFrameFormat.ParameterValues) { if (options.StackFrameFormat.ParameterTypes || options.StackFrameFormat.ParameterNames) { methodNameBuilder.Append(" = "); } var val = parameters[n].Value ?? string.Empty; methodNameBuilder.Append(val.Replace("\r\n", " ").Replace("\n", " ")); } } methodNameBuilder.Append(')'); } return(methodNameBuilder.ToString()); }
public ObjectValue[] GetParameters(EvaluationOptions options) { if (!hasDebugInfo) return new ObjectValue [0]; var values = sourceBacktrace.GetParameters (index, options); ObjectValue.ConnectCallbacks (this, values); return values; }
internal CorEvaluationContext(CorDebuggerSession session, CorBacktrace backtrace, int index, DC.EvaluationOptions ops) : base(ops) { Session = session; base.Adapter = session.ObjectAdapter; frameIndex = index; this.backtrace = backtrace; evalTimestamp = CorDebuggerSession.EvaluationTimestamp; Evaluator = session.GetEvaluator(CorBacktrace.CreateFrame(session, Frame)); }
/// <summary> /// Returns True if the expression is valid and can be evaluated for this frame. /// </summary> public ValidationResult ValidateExpression(string expression, EvaluationOptions options) { if (options.UseExternalTypeResolver) expression = ResolveExpression (expression); return sourceBacktrace.ValidateExpression (index, expression, options); }
public virtual Task <string> GetFullStackFrameTextAsync(EvaluationOptions options, CancellationToken cancellationToken = default(CancellationToken)) { return(GetFullStackFrameTextAsync(options, true, cancellationToken)); }