コード例 #1
0
 public abstract DbgEngineValueNode CreateTypeVariables(DbgEvaluationContext context, DbgStackFrame frame, DbgDotNetTypeVariableInfo[] typeVariableInfos, CancellationToken cancellationToken);
コード例 #2
0
        public override ValueNodesProviderResult GetNodes(DbgEvaluationContext context, DbgLanguage language, DbgStackFrame frame, DbgEvaluationOptions evalOptions, DbgValueNodeEvaluationOptions nodeEvalOptions)
        {
            var recreateAllNodes = forceRecreateAllNodesl;

            forceRecreateAllNodesl = false;

            var cancellationToken         = CancellationToken.None;
            const CultureInfo cultureInfo = null;
            var exceptions    = language.ExceptionsProvider.GetNodes(context, frame, nodeEvalOptions, cancellationToken);
            var returnValues  = language.ReturnValuesProvider.GetNodes(context, frame, nodeEvalOptions, cancellationToken);
            var variables     = language.LocalsProvider.GetNodes(context, frame, nodeEvalOptions, GetLocalsValueNodeOptions(), cancellationToken);
            var typeVariables = language.TypeVariablesProvider.GetNodes(context, frame, nodeEvalOptions, cancellationToken);

            var objectIds = dbgObjectIdService.GetObjectIds(frame.Runtime);

            Array.Sort(objectIds, DbgObjectIdComparer.Instance);

            int count = exceptions.Length + returnValues.Length + objectIds.Length + variables.Length + typeVariables.Length;

            if (count == 0)
            {
                return(new ValueNodesProviderResult(Array.Empty <DbgValueNodeInfo>(), false));
            }
            var res = new DbgValueNodeInfo[count];
            int ri  = 0;

            for (int i = 0; i < exceptions.Length; i++, ri++)
            {
                ulong id        = (uint)i;
                var   exception = exceptions[i];
                if (exception.ImageName == PredefinedDbgValueNodeImageNames.StowedException)
                {
                    id |= 1UL << 32;
                }
                res[ri] = new DbgValueNodeInfo(exception, GetNextExceptionId(id), causesSideEffects: false);
            }
            for (int i = 0; i < returnValues.Length; i++, ri++)
            {
                res[ri] = new DbgValueNodeInfo(returnValues[i], GetNextReturnValueId(), causesSideEffects: false);
            }

            var objectIdNodes = language.ValueNodeFactory.Create(context, frame, objectIds, nodeEvalOptions);

            Debug.Assert(objectIdNodes.Length == objectIds.Length);
            for (int i = 0; i < objectIdNodes.Length; i++, ri++)
            {
                var id = GetObjectIdNodeId(objectIds[i]);
                res[ri] = new DbgValueNodeInfo(objectIdNodes[i], id, causesSideEffects: false);
            }

            variables = GetSortedVariables(context, frame, variables, cultureInfo, cancellationToken);
            for (int i = 0; i < variables.Length; i++, ri++)
            {
                res[ri] = new DbgValueNodeInfo(variables[i].ValueNode, causesSideEffects: false);
            }

            for (int i = 0; i < typeVariables.Length; i++, ri++)
            {
                res[ri] = new DbgValueNodeInfo(typeVariables[i], GetNextTypeVariableId((uint)i), causesSideEffects: false);
            }

            if (res.Length != ri)
            {
                throw new InvalidOperationException();
            }

            return(new ValueNodesProviderResult(res, recreateAllNodes));
        }
コード例 #3
0
 string GetName(DbgEvaluationContext context, DbgStackFrame frame, StringBuilderTextColorOutput output, DbgValueNode valueNode, CultureInfo cultureInfo, CancellationToken cancellationToken)
 {
     output.Reset();
     valueNode.FormatName(context, frame, output, cultureInfo, cancellationToken);
     return(output.ToString());
 }
コード例 #4
0
 public override DbgLocalsValueNodeInfo[] GetNodes(DbgEvaluationContext context, DbgStackFrame frame, DbgValueNodeEvaluationOptions options, DbgLocalsValueNodeEvaluationOptions localsOptions, CancellationToken cancellationToken)
 {
     if (context == null)
     {
         throw new ArgumentNullException(nameof(context));
     }
     if (!(context is DbgEvaluationContextImpl))
     {
         throw new ArgumentException();
     }
     if (context.Language != Language)
     {
         throw new ArgumentException();
     }
     if (context.Runtime.RuntimeKindGuid != runtimeKindGuid)
     {
         throw new ArgumentException();
     }
     if (frame == null)
     {
         throw new ArgumentNullException(nameof(frame));
     }
     if (frame.Runtime.RuntimeKindGuid != runtimeKindGuid)
     {
         throw new ArgumentException();
     }
     return(DbgValueNodeUtils.ToLocalsValueNodeInfoArray(Language, frame.Runtime, engineLocalsValueNodeProvider.GetNodes(context, frame, options, localsOptions, cancellationToken)));
 }
コード例 #5
0
 /// <summary>
 /// Compiles an assignment
 /// </summary>
 /// <param name="context">Evaluation context</param>
 /// <param name="frame">Frame</param>
 /// <param name="references">.NET module references</param>
 /// <param name="aliases">Aliases</param>
 /// <param name="target">Target expression (lhs)</param>
 /// <param name="expression">Expression (rhs)</param>
 /// <param name="options">Options</param>
 /// <param name="cancellationToken">Cancellation token</param>
 /// <returns></returns>
 public abstract DbgDotNetCompilationResult CompileAssignment(DbgEvaluationContext context, DbgStackFrame frame, DbgModuleReference[] references, DbgDotNetAlias[] aliases, string target, string expression, DbgEvaluationOptions options, CancellationToken cancellationToken);
コード例 #6
0
 public override void Format(DbgEvaluationContext context, DbgStackFrame frame, IDbgValueNodeFormatParameters options, CultureInfo cultureInfo, CancellationToken cancellationToken)
 {
 }
コード例 #7
0
 public override DbgEngineEvaluationResult Evaluate(DbgEvaluationContext context, DbgStackFrame frame, string expression, DbgEvaluationOptions options, CancellationToken cancellationToken) => new DbgEngineEvaluationResult(ERROR);
コード例 #8
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="context">Evaluation context</param>
 /// <param name="frame">Stack frame</param>
 /// <param name="cancellationToken">Cancellation token</param>
 public DmdEvaluatorContext(DbgEvaluationContext context, DbgStackFrame frame, CancellationToken cancellationToken = default)
 {
     EvaluationContext = context;
     Frame             = frame;
     CancellationToken = cancellationToken;
 }
コード例 #9
0
 /// <summary>
 /// Evaluates an expression. It blocks the current thread until the evaluation is complete.
 /// </summary>
 /// <param name="context">Evaluation context</param>
 /// <param name="frame">Frame</param>
 /// <param name="expression">Expression to evaluate</param>
 /// <param name="options">Options</param>
 /// <param name="cancellationToken">Cancellation token</param>
 /// <returns></returns>
 public abstract DbgEngineEvaluationResult Evaluate(DbgEvaluationContext context, DbgStackFrame frame, string expression, DbgEvaluationOptions options, CancellationToken cancellationToken);
コード例 #10
0
 public override DbgEngineValueNode CreateError(DbgEvaluationContext context, DbgStackFrame frame, DbgDotNetText name, string errorMessage, string expression, bool causesSideEffects, CancellationToken cancellationToken) =>
 new DbgEngineValueNodeImpl(this, factory.CreateError(context, frame, name, errorMessage, expression, causesSideEffects, cancellationToken));
コード例 #11
0
 public override DbgEngineValueNode CreateTypeVariables(DbgEvaluationContext context, DbgStackFrame frame, DbgDotNetTypeVariableInfo[] typeVariableInfos, CancellationToken cancellationToken) =>
 new DbgEngineValueNodeImpl(this, factory.CreateTypeVariables(context, frame, typeVariableInfos, cancellationToken));
コード例 #12
0
 public override DbgEngineValueNode CreateReturnValue(DbgEvaluationContext context, DbgStackFrame frame, uint id, DbgDotNetValue value, DbgValueNodeEvaluationOptions options, DmdMethodBase method, CancellationToken cancellationToken) =>
 new DbgEngineValueNodeImpl(this, factory.CreateReturnValue(context, frame, id, value, options, method, cancellationToken));
コード例 #13
0
 public override DbgEngineValueNode CreateStowedException(DbgEvaluationContext context, DbgStackFrame frame, uint id, DbgDotNetValue value, DbgValueNodeEvaluationOptions options, CancellationToken cancellationToken) =>
 new DbgEngineValueNodeImpl(this, factory.CreateStowedException(context, frame, id, value, options, cancellationToken));
コード例 #14
0
 public override DbgEngineValueNode Create(DbgEvaluationContext context, DbgStackFrame frame, DbgDotNetText name, DbgDotNetValue value, DbgValueNodeEvaluationOptions options, string expression, string imageName, bool isReadOnly, bool causesSideEffects, DmdType expectedType, CancellationToken cancellationToken) =>
 new DbgEngineValueNodeImpl(this, factory.Create(context, frame, name, value, options, expression, imageName, isReadOnly, causesSideEffects, expectedType, cancellationToken));
コード例 #15
0
 public override ulong GetChildCount(DbgEvaluationContext context, DbgStackFrame frame, CancellationToken cancellationToken) => 0;
コード例 #16
0
 /// <summary>
 /// Assigns the value of an expression to another expression. It blocks the current thread until the evaluation is complete.
 /// </summary>
 /// <param name="context">Evaluation context</param>
 /// <param name="frame">Frame</param>
 /// <param name="expression">Target expression (lhs)</param>
 /// <param name="valueExpression">Source expression (rhs)</param>
 /// <param name="options">Options</param>
 /// <param name="cancellationToken">Cancellation token</param>
 /// <returns></returns>
 public abstract DbgEngineEEAssignmentResult Assign(DbgEvaluationContext context, DbgStackFrame frame, string expression, string valueExpression, DbgEvaluationOptions options, CancellationToken cancellationToken);
コード例 #17
0
 public override DbgEngineValueNode[] GetChildren(DbgEvaluationContext context, DbgStackFrame frame, ulong index, int count, DbgValueNodeEvaluationOptions options, CancellationToken cancellationToken) => Array.Empty <DbgEngineValueNode>();
コード例 #18
0
        DbgEngineLocalsValueNodeInfo[] GetNodesCore(DbgEvaluationContext context, DbgStackFrame frame, DbgValueNodeEvaluationOptions options, DbgLocalsValueNodeEvaluationOptions localsOptions, CancellationToken cancellationToken)
        {
            DbgEngineLocalsValueNodeInfo[] valueNodes = null;
            try {
                var refsResult = dbgModuleReferenceProvider.GetModuleReferences(context.Runtime, frame);
                if (refsResult.ErrorMessage != null)
                {
                    return(Array.Empty <DbgEngineLocalsValueNodeInfo>());
                }

                var languageDebugInfo = context.TryGetLanguageDebugInfo();
                if (languageDebugInfo == null)
                {
                    return(Array.Empty <DbgEngineLocalsValueNodeInfo>());
                }
                var methodDebugInfo = languageDebugInfo.MethodDebugInfo;
                var module          = frame.Module ?? throw new InvalidOperationException();

                // Since we attach this to the module, the module doesn't have to be part of Key
                var state = StateWithKey <GetNodesState> .GetOrCreate(module, this);

                var localsOptionsKey = localsOptions & ~(DbgLocalsValueNodeEvaluationOptions.ShowCompilerGeneratedVariables | DbgLocalsValueNodeEvaluationOptions.ShowDecompilerGeneratedVariables);
                var key = new GetNodesState.Key(methodDebugInfo.DecompilerOptionsVersion, options, localsOptionsKey,
                                                methodDebugInfo.Method.MDToken.ToInt32(), languageDebugInfo.MethodVersion,
                                                refsResult.ModuleReferences, GetScope(methodDebugInfo.Scope, languageDebugInfo.ILOffset));

                var evalOptions = DbgEvaluationOptions.None;
                if ((options & DbgValueNodeEvaluationOptions.NoFuncEval) != 0)
                {
                    evalOptions |= DbgEvaluationOptions.NoFuncEval;
                }

                ValueInfo[] valueInfos;
                byte[]      assemblyBytes;
                int         compilerGeneratedCount;
                int         decompilerGeneratedCount;
                if (key.Equals(state.CachedKey))
                {
                    valueInfos               = state.CachedValueInfos;
                    assemblyBytes            = state.CachedAssemblyBytes;
                    decompilerGeneratedCount = state.CachedDecompilerGeneratedCount;
                    compilerGeneratedCount   = state.CachedCompilerGeneratedCount;
                }
                else
                {
                    var compilationResult = expressionCompiler.CompileGetLocals(context, frame, refsResult.ModuleReferences, evalOptions, cancellationToken);
                    cancellationToken.ThrowIfCancellationRequested();
                    if (compilationResult.IsError)
                    {
                        return new[] { CreateInternalErrorNode(context, frame, compilationResult.ErrorMessage, cancellationToken) }
                    }
                    ;

                    decompilerGeneratedCount = GetDecompilerGeneratedVariablesCount(methodDebugInfo.Scope, languageDebugInfo.ILOffset);

                    valueInfos = new ValueInfo[compilationResult.CompiledExpressions.Length + decompilerGeneratedCount];
                    int valueInfosIndex = 0;
                    compilerGeneratedCount = 0;
                    for (int i = 0; i < compilationResult.CompiledExpressions.Length; i++, valueInfosIndex++)
                    {
                        if ((compilationResult.CompiledExpressions[i].ResultFlags & DbgDotNetCompiledExpressionResultFlags.CompilerGenerated) != 0)
                        {
                            compilerGeneratedCount++;
                        }
                        valueInfos[valueInfosIndex] = new CompiledExpressionValueInfo(compilationResult.CompiledExpressions, i);
                    }

                    if (decompilerGeneratedCount > 0)
                    {
                        var scope = methodDebugInfo.Scope;
                        for (;;)
                        {
                            foreach (var local in scope.Locals)
                            {
                                if (local.IsDecompilerGenerated)
                                {
                                    valueInfos[valueInfosIndex] = new DecompilerGeneratedVariableValueInfo(local.Name);
                                    valueInfosIndex++;
                                }
                            }

                            bool found = false;
                            foreach (var childScope in scope.Scopes)
                            {
                                if (childScope.Span.Start <= languageDebugInfo.ILOffset && languageDebugInfo.ILOffset < childScope.Span.End)
                                {
                                    found = true;
                                    scope = childScope;
                                    break;
                                }
                            }
                            if (!found)
                            {
                                break;
                            }
                        }
                    }

                    if (valueInfos.Length != valueInfosIndex)
                    {
                        throw new InvalidOperationException();
                    }

                    assemblyBytes                        = compilationResult.Assembly;
                    state.CachedKey                      = key;
                    state.CachedValueInfos               = valueInfos;
                    state.CachedAssemblyBytes            = assemblyBytes;
                    state.CachedILInterpreterState       = null;
                    state.CachedDecompilerGeneratedCount = decompilerGeneratedCount;
                    state.CachedCompilerGeneratedCount   = compilerGeneratedCount;
                }

                int count = valueInfos.Length;
                if ((localsOptions & DbgLocalsValueNodeEvaluationOptions.ShowCompilerGeneratedVariables) == 0)
                {
                    count -= compilerGeneratedCount;
                }
                if ((localsOptions & DbgLocalsValueNodeEvaluationOptions.ShowDecompilerGeneratedVariables) == 0)
                {
                    count -= decompilerGeneratedCount;
                }
                valueNodes = count == 0 ? Array.Empty <DbgEngineLocalsValueNodeInfo>() : new DbgEngineLocalsValueNodeInfo[count];
                var valueCreator = new DbgDotNetValueCreator(valueNodeFactory, dnILInterpreter, context, frame, options, evalOptions, assemblyBytes, cancellationToken);
                int w            = 0;
                for (int i = 0; i < valueInfos.Length; i++)
                {
                    cancellationToken.ThrowIfCancellationRequested();
                    var valueInfo = valueInfos[i];

                    DbgEngineLocalsValueNodeInfo valueNodeInfo;
                    switch (valueInfo.Kind)
                    {
                    case ValueInfoKind.CompiledExpression:
                        var compExpr = (CompiledExpressionValueInfo)valueInfo;
                        if ((localsOptions & DbgLocalsValueNodeEvaluationOptions.ShowCompilerGeneratedVariables) == 0 && compExpr.IsCompilerGenerated)
                        {
                            continue;
                        }
                        valueNodeInfo = new DbgEngineLocalsValueNodeInfo(
                            compExpr.IsParameter ? DbgLocalsValueNodeKind.Parameter : DbgLocalsValueNodeKind.Local,
                            valueCreator.CreateValueNode(ref state.CachedILInterpreterState, ref compExpr.CompiledExpressionResult));
                        break;

                    case ValueInfoKind.DecompilerGeneratedVariable:
                        if ((localsOptions & DbgLocalsValueNodeEvaluationOptions.ShowDecompilerGeneratedVariables) == 0)
                        {
                            continue;
                        }
                        var decGen = (DecompilerGeneratedVariableValueInfo)valueInfo;
                        valueNodeInfo = new DbgEngineLocalsValueNodeInfo(DbgLocalsValueNodeKind.Local,
                                                                         valueNodeFactory.CreateError(context, frame,
                                                                                                      new DbgDotNetText(new DbgDotNetTextPart(BoxedTextColor.Local, decGen.Name)),
                                                                                                      dnSpy_Debugger_DotNet_Resources.DecompilerGeneratedVariablesCanNotBeEvaluated,
                                                                                                      decGen.Name, false, cancellationToken));
                        break;

                    default:
                        throw new InvalidOperationException();
                    }

                    valueNodes[w++] = valueNodeInfo;
                }
                if (w != valueNodes.Length)
                {
                    throw new InvalidOperationException();
                }

                return(valueNodes);
            }
            catch (Exception ex) {
                if (valueNodes != null)
                {
                    frame.Process.DbgManager.Close(valueNodes.Select(a => a.ValueNode).Where(a => a != null));
                }
                if (!ExceptionUtils.IsInternalDebuggerError(ex))
                {
                    throw;
                }
                return(new[] { CreateInternalErrorNode(context, frame, PredefinedEvaluationErrorMessages.InternalDebuggerError, cancellationToken) });
            }
        }
コード例 #19
0
 public override DbgEngineValueNodeAssignmentResult Assign(DbgEvaluationContext context, DbgStackFrame frame, string expression, DbgEvaluationOptions options, CancellationToken cancellationToken) => new DbgEngineValueNodeAssignmentResult(DbgEEAssignmentResultFlags.None, NullDbgEngineExpressionEvaluator.ERROR);
コード例 #20
0
 DbgEngineLocalsValueNodeInfo CreateInternalErrorNode(DbgEvaluationContext context, DbgStackFrame frame, string errorMessage, CancellationToken cancellationToken) =>
 new DbgEngineLocalsValueNodeInfo(DbgLocalsValueNodeKind.Error, valueNodeFactory.CreateError(context, frame, new DbgDotNetText(new DbgDotNetTextPart(BoxedTextColor.Text, "<error>")), errorMessage, "<internal.error>", false, cancellationToken));
コード例 #21
0
 public override DbgEngineEEAssignmentResult Assign(DbgEvaluationContext context, DbgStackFrame frame, string expression, string valueExpression, DbgEvaluationOptions options, CancellationToken cancellationToken) => new DbgEngineEEAssignmentResult(DbgEEAssignmentResultFlags.CompilerError, ERROR);
コード例 #22
0
        public override DbgEngineLocalsValueNodeInfo[] GetNodes(DbgEvaluationContext context, DbgStackFrame frame, DbgValueNodeEvaluationOptions options, DbgLocalsValueNodeEvaluationOptions localsOptions, CancellationToken cancellationToken)
        {
            var dispatcher = context.Runtime.GetDotNetRuntime().Dispatcher;

            if (dispatcher.CheckAccess())
            {
                return(GetNodesCore(context, frame, options, localsOptions, cancellationToken));
            }
            return(GetNodes(dispatcher, context, frame, options, localsOptions, cancellationToken));

            DbgEngineLocalsValueNodeInfo[] GetNodes(DbgDotNetDispatcher dispatcher2, DbgEvaluationContext context2, DbgStackFrame frame2, DbgValueNodeEvaluationOptions options2, DbgLocalsValueNodeEvaluationOptions localsOptions2, CancellationToken cancellationToken2) =>
            dispatcher2.InvokeRethrow(() => GetNodesCore(context2, frame2, options2, localsOptions2, cancellationToken2));
        }
コード例 #23
0
 /// <summary>
 /// Creates an assembly that is used to get all the locals
 /// </summary>
 /// <param name="context">Evaluation context</param>
 /// <param name="frame">Frame</param>
 /// <param name="references">.NET module references</param>
 /// <param name="options">Options</param>
 /// <param name="cancellationToken">Cancellation token</param>
 /// <returns></returns>
 public abstract DbgDotNetCompilationResult CompileGetLocals(DbgEvaluationContext context, DbgStackFrame frame, DbgModuleReference[] references, DbgEvaluationOptions options, CancellationToken cancellationToken);
コード例 #24
0
 public override DbgEngineValueNode[] GetNodes(DbgEvaluationContext context, DbgStackFrame frame, DbgValueNodeEvaluationOptions options, CancellationToken cancellationToken) => Array.Empty <DbgEngineValueNode>();
コード例 #25
0
 /// <summary>
 /// Called after the <see cref="DbgStackFrame"/> has been created
 /// </summary>
 /// <param name="frame">Stack frame</param>
 public abstract void OnFrameCreated(DbgStackFrame frame);
コード例 #26
0
 public override DbgEngineValueNode[] Create(DbgEvaluationContext context, DbgStackFrame frame, DbgExpressionEvaluationInfo[] expressions, CancellationToken cancellationToken) => expressions.Select(a => new NullDbgEngineErrorValueNode(a.Expression)).ToArray();
コード例 #27
0
        DbgLocalsValueNodeInfo[] GetSortedVariables(DbgEvaluationContext context, DbgStackFrame frame, DbgLocalsValueNodeInfo[] variables, CultureInfo cultureInfo, CancellationToken cancellationToken)
        {
            if (variables.Length <= 1)
            {
                return(variables);
            }

            var sortParameters = debuggerSettings.SortParameters;
            var sortLocals     = debuggerSettings.SortLocals;

            // If the default options are used, don't sort at all. Let the locals provider
            // decide how to sort them.
            if (!sortParameters && !sortLocals)
            {
                return(variables);
            }

            var output = new StringBuilderTextColorOutput();

            if (debuggerSettings.GroupParametersAndLocalsTogether)
            {
                return(variables.OrderBy(a => GetName(context, frame, output, a.ValueNode, cultureInfo, cancellationToken), StringComparer.OrdinalIgnoreCase).ToArray());
            }
            else
            {
                var locals     = variables.Where(a => a.Kind == DbgLocalsValueNodeKind.Local).ToArray();
                var parameters = variables.Where(a => a.Kind == DbgLocalsValueNodeKind.Parameter).ToArray();
                var others     = variables.Where(a => a.Kind != DbgLocalsValueNodeKind.Local && a.Kind != DbgLocalsValueNodeKind.Parameter).ToArray();

                if (sortLocals && locals.Length > 1)
                {
                    locals = locals.OrderBy(a => GetName(context, frame, output, a.ValueNode, cultureInfo, cancellationToken), StringComparer.OrdinalIgnoreCase).ToArray();
                }
                if (sortParameters && parameters.Length > 1)
                {
                    parameters = parameters.OrderBy(a => GetName(context, frame, output, a.ValueNode, cultureInfo, cancellationToken), StringComparer.OrdinalIgnoreCase).ToArray();
                }
                if ((sortLocals || sortParameters) && others.Length > 1)
                {
                    others = others.OrderBy(a => GetName(context, frame, output, a.ValueNode, cultureInfo, cancellationToken), StringComparer.OrdinalIgnoreCase).ToArray();
                }

                var res = new DbgLocalsValueNodeInfo[locals.Length + parameters.Length + others.Length];
                int w   = 0;
                for (int i = 0; i < parameters.Length; i++)
                {
                    res[w++] = parameters[i];
                }
                for (int i = 0; i < locals.Length; i++)
                {
                    res[w++] = locals[i];
                }
                for (int i = 0; i < others.Length; i++)
                {
                    res[w++] = others[i];
                }
                if (w != res.Length)
                {
                    throw new InvalidOperationException();
                }
                return(res);
            }
        }
コード例 #28
0
 public override DbgEngineValueNode[] Create(DbgEvaluationContext context, DbgStackFrame frame, DbgEngineObjectId[] objectIds, DbgValueNodeEvaluationOptions options, CancellationToken cancellationToken) => objectIds.Select(a => new NullDbgEngineErrorValueNode()).ToArray();
コード例 #29
0
 /// <summary>
 /// Gets the module references or an empty array if <paramref name="frame"/> is an unsupported frame with no .NET module
 /// </summary>
 /// <param name="runtime">Runtime</param>
 /// <param name="frame">Frame</param>
 /// <returns></returns>
 public abstract GetModuleReferencesResult GetModuleReferences(DbgRuntime runtime, DbgStackFrame frame);
コード例 #30
0
 public abstract DbgEngineValueNode CreateError(DbgEvaluationContext context, DbgStackFrame frame, DbgDotNetText name, string errorMessage, string expression, bool causesSideEffects, CancellationToken cancellationToken);