string IDkmClrFullNameProvider.GetClrTypeName(DkmInspectionContext inspectionContext, DkmClrType clrType, DkmClrCustomTypeInfo customTypeInfo)
{
Debug.Assert(inspectionContext != null);
bool sawInvalidIdentifier;
var name = GetTypeName(new TypeAndCustomInfo(clrType, customTypeInfo), escapeKeywordIdentifiers: true, sawInvalidIdentifier: out sawInvalidIdentifier);
return sawInvalidIdentifier ? null : name;
}
private DkmSuccessEvaluationResult(
DkmInspectionContext inspectionContext,
DkmStackWalkFrame stackFrame,
string name,
string fullName,
DkmEvaluationResultFlags flags,
string value,
string editableValue,
string type,
DkmEvaluationResultCategory category,
DkmEvaluationResultAccessType access,
DkmEvaluationResultStorageType storageType,
DkmEvaluationResultTypeModifierFlags typeModifierFlags,
DkmDataAddress address,
ReadOnlyCollection<DkmCustomUIVisualizerInfo> customUIVisualizers,
ReadOnlyCollection<DkmModuleInstance> externalModules,
DkmDataItem dataItem) :
base(inspectionContext, stackFrame, name, fullName, flags, type, dataItem)
{
this.Value = value;
this.EditableValue = editableValue;
this.Category = category;
this.Access = access;
this.StorageType = storageType;
this.TypeModifierFlags = typeModifierFlags;
this.CustomUIVisualizers = customUIVisualizers;
}
string IDkmClrFormatter.GetValueString(DkmClrValue value, DkmInspectionContext inspectionContext, ReadOnlyCollection<string> formatSpecifiers)
{
var options = ((inspectionContext.EvaluationFlags & DkmEvaluationFlags.NoQuotes) == 0) ?
ObjectDisplayOptions.UseQuotes :
ObjectDisplayOptions.None;
return GetValueString(value, inspectionContext, options, GetValueFlags.IncludeObjectId);
}
/// <summary>
/// Generate a Results Only row if the value is a synthesized
/// value declared as IEnumerable or IEnumerable<T>.
/// </summary>
internal static EvalResultDataItem CreateResultsOnlyRowIfSynthesizedEnumerable(
DkmInspectionContext inspectionContext,
string name,
DkmClrType declaredType,
DkmClrCustomTypeInfo declaredTypeInfo,
DkmClrValue value,
Formatter formatter)
{
if ((value.ValueFlags & DkmClrValueFlags.Synthetic) == 0)
{
return null;
}
// Must be declared as IEnumerable or IEnumerable<T>, not a derived type.
var enumerableType = GetEnumerableType(value, declaredType, requireExactInterface: true);
if (enumerableType == null)
{
return null;
}
var expansion = CreateExpansion(inspectionContext, value, enumerableType, formatter);
if (expansion == null)
{
return null;
}
return expansion.CreateResultsViewRow(
inspectionContext,
name,
new TypeAndCustomInfo(declaredType.GetLmrType(), declaredTypeInfo),
value,
includeResultsFormatSpecifier: false,
formatter: formatter);
}
DkmCompiledClrLocalsQuery IDkmClrExpressionCompiler.GetClrLocalVariableQuery(
DkmInspectionContext inspectionContext,
DkmClrInstructionAddress instructionAddress,
bool argumentsOnly)
{
try
{
var references = instructionAddress.Process.GetMetadataBlocks(instructionAddress.ModuleInstance.AppDomain);
var context = this.CreateMethodContext(instructionAddress, references);
var builder = ArrayBuilder<LocalAndMethod>.GetInstance();
string typeName;
var assembly = context.CompileGetLocals(
builder,
argumentsOnly,
out typeName,
testData: null);
Debug.Assert((builder.Count == 0) == (assembly.Count == 0));
var locals = new ReadOnlyCollection<DkmClrLocalVariableInfo>(builder.SelectAsArray(l => DkmClrLocalVariableInfo.Create(l.LocalName, l.MethodName, l.Flags, DkmEvaluationResultCategory.Data)));
builder.Free();
return DkmCompiledClrLocalsQuery.Create(inspectionContext.RuntimeInstance, null, this.CompilerId, assembly, typeName, locals);
}
catch (Exception e) when (ExpressionEvaluatorFatalError.CrashIfFailFastEnabled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
private EvalResult GetRow(
ResultProvider resultProvider,
DkmInspectionContext inspectionContext,
DkmClrValue value,
int index,
EvalResultDataItem parent)
{
var indices = GetIndices(index);
var fullNameProvider = resultProvider.FullNameProvider;
var name = fullNameProvider.GetClrArrayIndexExpression(inspectionContext, indices);
var element = value.GetArrayElement(indices, inspectionContext);
var fullName = GetFullName(inspectionContext, parent, name, fullNameProvider);
return resultProvider.CreateDataItem(
inspectionContext,
name,
typeDeclaringMemberAndInfo: default(TypeAndCustomInfo),
declaredTypeAndInfo: _elementTypeAndInfo,
value: element,
useDebuggerDisplay: parent != null,
expansionFlags: ExpansionFlags.IncludeBaseMembers,
childShouldParenthesize: false,
fullName: fullName,
formatSpecifiers: Formatter.NoFormatSpecifiers,
category: DkmEvaluationResultCategory.Other,
flags: element.EvalFlags,
evalFlags: inspectionContext.EvaluationFlags);
}
private EvalResult GetRow(
DkmInspectionContext inspectionContext,
DkmClrValue value,
int index,
EvalResultDataItem parent)
{
var typeParameter = _typeParameters[index];
var typeArgument = _typeArguments[index];
var typeArgumentInfo = _customTypeInfoMap.SubstituteCustomTypeInfo(typeParameter, customInfo: null);
var formatSpecifiers = Formatter.NoFormatSpecifiers;
return new EvalResult(
ExpansionKind.TypeVariable,
typeParameter.Name,
typeDeclaringMemberAndInfo: default(TypeAndCustomInfo),
declaredTypeAndInfo: new TypeAndCustomInfo(DkmClrType.Create(value.Type.AppDomain, typeArgument), typeArgumentInfo),
useDebuggerDisplay: parent != null,
value: value,
displayValue: inspectionContext.GetTypeName(DkmClrType.Create(value.Type.AppDomain, typeArgument), typeArgumentInfo, formatSpecifiers),
expansion: null,
childShouldParenthesize: false,
fullName: null,
childFullNamePrefixOpt: null,
formatSpecifiers: formatSpecifiers,
category: DkmEvaluationResultCategory.Data,
flags: DkmEvaluationResultFlags.ReadOnly,
editableValue: null,
inspectionContext: inspectionContext);
}
/// <summary>
/// This method is called by the debug engine to compile an expression that the user wants
/// to evaluate. Before the call, we have the text of the expression and information about
/// the context we want to evaluate in (code location, evaluation flags, etc.). The result
/// of the call is a "query" containing IL the debugger will execute to get the
/// result of the expression.
/// </summary>
/// <param name="expression">This is the raw expression to compile</param>
/// <param name="instructionAddress">Instruction address or code location to use as the
/// context of the compilation.</param>
/// <param name="inspectionContext">Context of the evaluation. This contains options/flags
/// to be used during compilation. It also contains the InspectionSession. The inspection
/// session is the object that provides lifetime management for our objects. When the user
/// steps or continues the process, the debug engine will dispose of the inspection session</param>
/// <param name="error">[Out] If the there are any compile errors, this parameter is set to
/// the error message to display to the user</param>
/// <param name="result">[Out] If compilation was successful, this is the output query.</param>
void IDkmClrExpressionCompiler.CompileExpression(
DkmLanguageExpression expression,
DkmClrInstructionAddress instructionAddress,
DkmInspectionContext inspectionContext,
out string error,
out DkmCompiledClrInspectionQuery result)
{
error = null;
result = null;
using (DebugCompilerContext context = ContextFactory.CreateExpressionContext(inspectionContext, instructionAddress, expression.Text))
{
context.GenerateQuery();
error = context.FirstError;
if (string.IsNullOrEmpty(error))
{
result = DkmCompiledClrInspectionQuery.Create(
instructionAddress.RuntimeInstance,
null,
expression.Language.Id,
new ReadOnlyCollection<byte>(context.GetPeBytes()),
context.ClassName,
context.MethodName,
new ReadOnlyCollection<string>(context.FormatSpecifiers),
context.ResultFlags,
DkmEvaluationResultCategory.Data,
DkmEvaluationResultAccessType.None,
DkmEvaluationResultStorageType.None,
DkmEvaluationResultTypeModifierFlags.None,
null);
}
}
}
internal override void GetRows(
ResultProvider resultProvider,
ArrayBuilder<EvalResult> rows,
DkmInspectionContext inspectionContext,
EvalResultDataItem parent,
DkmClrValue value,
int startIndex,
int count,
bool visitAll,
ref int index)
{
var fields = GetFields();
int startIndex2;
int count2;
GetIntersection(startIndex, count, index, fields.Count, out startIndex2, out count2);
int offset = startIndex2 - index;
for (int i = 0; i < count2; i++)
{
var row = GetMemberRow(resultProvider, inspectionContext, value, fields[i + offset], parent);
rows.Add(row);
}
index += fields.Count;
}
internal static DynamicViewExpansion CreateExpansion(DkmInspectionContext inspectionContext, DkmClrValue value, ResultProvider resultProvider)
{
if (value.IsError() || value.IsNull || value.HasExceptionThrown())
{
return null;
}
var type = value.Type.GetLmrType();
if (!(type.IsComObject() || type.IsIDynamicMetaObjectProvider()))
{
return null;
}
var proxyValue = value.InstantiateDynamicViewProxy(inspectionContext);
Debug.Assert((proxyValue == null) || (!proxyValue.IsNull && !proxyValue.IsError() && !proxyValue.HasExceptionThrown()));
// InstantiateDynamicViewProxy may return null (if required assembly is missing, for instance).
if (proxyValue == null)
{
return null;
}
// Expansion is based on the 'DynamicMetaObjectProviderDebugView.Items' property.
var proxyType = proxyValue.Type;
var itemsMemberExpansion = RootHiddenExpansion.CreateExpansion(
proxyType.GetMemberByName("Items"),
DynamicFlagsMap.Create(new TypeAndCustomInfo(proxyType)));
return new DynamicViewExpansion(proxyValue, itemsMemberExpansion);
}
void IDkmClrResultProvider.GetResult(DkmClrValue value, DkmWorkList workList, DkmClrType declaredType, DkmClrCustomTypeInfo declaredTypeInfo, DkmInspectionContext inspectionContext, ReadOnlyCollection<string> formatSpecifiers, string resultName, string resultFullName, DkmCompletionRoutine<DkmEvaluationAsyncResult> completionRoutine)
{
if (formatSpecifiers == null)
{
formatSpecifiers = Formatter.NoFormatSpecifiers;
}
if (resultFullName != null)
{
ReadOnlyCollection<string> otherSpecifiers;
resultFullName = FullNameProvider.GetClrExpressionAndFormatSpecifiers(inspectionContext, resultFullName, out otherSpecifiers);
foreach (var formatSpecifier in otherSpecifiers)
{
formatSpecifiers = Formatter.AddFormatSpecifier(formatSpecifiers, formatSpecifier);
}
}
var wl = new WorkList(workList, e => completionRoutine(DkmEvaluationAsyncResult.CreateErrorResult(e)));
wl.ContinueWith(
() => GetRootResultAndContinue(
value,
wl,
declaredType,
declaredTypeInfo,
inspectionContext,
resultName,
resultFullName,
formatSpecifiers,
result => wl.ContinueWith(() => completionRoutine(new DkmEvaluationAsyncResult(result)))));
}
private DkmEvaluationResult GetRow(
ResultProvider resultProvider,
DkmInspectionContext inspectionContext,
DkmClrValue value,
int index,
EvalResultDataItem parent)
{
var indices = GetIndices(index);
var formatter = resultProvider.Formatter;
var name = formatter.GetArrayIndexExpression(indices);
var elementType = value.Type.ElementType;
var element = value.GetArrayElement(indices);
var fullName = GetFullName(parent, name, formatter);
var dataItem = resultProvider.CreateDataItem(
inspectionContext,
name,
typeDeclaringMember: null,
declaredType: elementType.GetLmrType(),
value: element,
parent: parent,
expansionFlags: ExpansionFlags.IncludeBaseMembers,
childShouldParenthesize: false,
fullName: fullName,
formatSpecifiers: Formatter.NoFormatSpecifiers,
category: DkmEvaluationResultCategory.Other,
flags: element.EvalFlags,
evalFlags: inspectionContext.EvaluationFlags);
return resultProvider.GetResult(dataItem, element.Type, elementType, parent);
}
private static string TryGetFrameReturnTypeHelper(DkmInspectionContext inspectionContext, DkmStackWalkFrame frame)
{
ImportedMethod currentMethod = TryGetCurrentMethod(inspectionContext, frame);
if (currentMethod == null)
return null;
return currentMethod.ReturnType.ToString();
}
internal static ResultsViewExpansion CreateExpansion(DkmInspectionContext inspectionContext, DkmClrValue value, Formatter formatter)
{
var enumerableType = GetEnumerableType(value);
if (enumerableType == null)
{
return null;
}
return CreateExpansion(inspectionContext, value, enumerableType, formatter);
}
public static DkmEvaluationResultEnumContext Create(int Count, DkmStackWalkFrame StackFrame, DkmInspectionContext InspectionContext, DkmDataItem DataItem)
{
var enumContext = new DkmEvaluationResultEnumContext(Count, InspectionContext);
if (DataItem != null)
{
enumContext.SetDataItem(DkmDataCreationDisposition.CreateNew, DataItem);
}
return enumContext;
}
/// <summary>
/// This method is called by the debug engine to get the text representation of the return
/// value of a stack frame.
/// </summary>
/// <param name="inspectionContext">Context of the evaluation. This contains options/flags
/// to be used during compilation. It also contains the InspectionSession. The inspection
/// session is the object that provides lifetime management for our objects. When the user
/// steps or continues the process, the debug engine will dispose of the inspection session</param>
/// <param name="workList">The current work list. This is used to batch asynchronous
/// work items. If any asynchronous calls are needed later, this is the work list to pass
/// to the asynchronous call. It's not needed in our case.</param>
/// <param name="frame">The frame to get the text representation of the return value for</param>
/// <param name="completionRoutine">Completion routine to call when work is completed</param>
void IDkmLanguageFrameDecoder.GetFrameReturnType(
DkmInspectionContext inspectionContext,
DkmWorkList workList,
DkmStackWalkFrame frame,
DkmCompletionRoutine<DkmGetFrameReturnTypeAsyncResult> completionRoutine)
{
string name = TryGetFrameReturnTypeHelper(inspectionContext, frame) ?? "<Unknown>";
completionRoutine(new DkmGetFrameReturnTypeAsyncResult(name));
}
/// <summary>
/// This method is called by the debug engine to get the text representation of a stack
/// frame.
/// </summary>
/// <param name="inspectionContext">Context of the evaluation. This contains options/flags
/// to be used during compilation. It also contains the InspectionSession. The inspection
/// session is the object that provides lifetime management for our objects. When the user
/// steps or continues the process, the debug engine will dispose of the inspection session</param>
/// <param name="workList">The current work list. This is used to batch asynchronous
/// work items. If any asynchronous calls are needed later, this is the work list to pass
/// to the asynchronous call. It's not needed in our case.</param>
/// <param name="frame">The frame to get the text representation for</param>
/// <param name="argumentFlags">Option flags to change the way we format frames</param>
/// <param name="completionRoutine">Completion routine to call when work is completed</param>
void IDkmLanguageFrameDecoder.GetFrameName(
DkmInspectionContext inspectionContext,
DkmWorkList workList,
DkmStackWalkFrame frame,
DkmVariableInfoFlags argumentFlags,
DkmCompletionRoutine<DkmGetFrameNameAsyncResult> completionRoutine)
{
string name = TryGetFrameNameHelper(inspectionContext, frame, argumentFlags) ?? "<Unknown Method>";
completionRoutine(new DkmGetFrameNameAsyncResult(name));
}
public void GetChildren(DkmWorkList workList, int initialRequestSize, DkmInspectionContext inspectionContext, DkmCompletionRoutine<DkmGetChildrenAsyncResult> completionRoutine)
{
InspectionContext.InspectionSession.InvokeResultProvider(
MethodId.GetChildren,
r =>
{
r.GetChildren(this, workList, initialRequestSize, inspectionContext, completionRoutine);
return (object)null;
});
}
/// <summary>
/// Get the rows within the given range. 'index' is advanced
/// to the end of the range, or if 'visitAll' is true, 'index' is
/// advanced to the end of the expansion.
/// </summary>
internal abstract void GetRows(
ResultProvider resultProvider,
ArrayBuilder<DkmEvaluationResult> rows,
DkmInspectionContext inspectionContext,
EvalResultDataItem parent,
DkmClrValue value,
int startIndex,
int count,
bool visitAll,
ref int index);
string IDkmClrFullNameProvider.GetClrCastExpression(DkmInspectionContext inspectionContext, string argument, DkmClrType type, DkmClrCustomTypeInfo customTypeInfo, bool parenthesizeArgument, bool parenthesizeEntireExpression)
{
bool sawInvalidIdentifier;
var name = GetTypeName(new TypeAndCustomInfo(type, customTypeInfo), escapeKeywordIdentifiers: true, sawInvalidIdentifier: out sawInvalidIdentifier);
if (sawInvalidIdentifier)
{
return null;
}
return GetCastExpression(argument, name, parenthesizeArgument, parenthesizeEntireExpression);
}
internal static EvalResultDataItem CreateMembersOnlyRow(
DkmInspectionContext inspectionContext,
string name,
DkmClrValue value,
Formatter formatter)
{
var expansion = CreateExpansion(inspectionContext, value, formatter);
return (expansion != null) ?
expansion.CreateDynamicViewRow(inspectionContext, name, parent: null, formatter: formatter) :
new EvalResultDataItem(name, Resources.DynamicViewNotDynamic);
}
internal static EvalResult CreateMembersOnlyRow(
DkmInspectionContext inspectionContext,
string name,
DkmClrValue value,
ResultProvider resultProvider)
{
var expansion = CreateExpansion(inspectionContext, value, resultProvider);
return (expansion != null) ?
expansion.CreateDynamicViewRow(inspectionContext, name, parent: null, fullNameProvider: resultProvider.FullNameProvider) :
new EvalResult(name, Resources.DynamicViewNotDynamic, inspectionContext);
}
void IDkmClrResultProvider.GetChildren(DkmEvaluationResult evaluationResult, DkmWorkList workList, int initialRequestSize, DkmInspectionContext inspectionContext, DkmCompletionRoutine<DkmGetChildrenAsyncResult> completionRoutine)
{
var dataItem = evaluationResult.GetDataItem<EvalResultDataItem>();
if (dataItem == null)
{
// We don't know about this result. Call next implementation
evaluationResult.GetChildren(workList, initialRequestSize, inspectionContext, completionRoutine);
return;
}
completionRoutine(GetChildren(inspectionContext, evaluationResult, dataItem, initialRequestSize));
}
/// <summary>
/// This method is called by the debug engine to populate the text representing the value
/// of an expression.
/// </summary>
/// <param name="clrValue">The raw value to get the text for</param>
/// <param name="inspectionContext">Context of the evaluation. This contains options/flags
/// to be used during compilation. It also contains the InspectionSession. The inspection
/// session is the object that provides lifetime management for our objects. When the user
/// steps or continues the process, the debug engine will dispose of the inspection session</param>
/// <param name="formatSpecifiers"></param>
/// <returns>The text representing the given value</returns>
string IDkmClrFormatter.GetValueString(DkmClrValue clrValue, DkmInspectionContext inspectionContext, ReadOnlyCollection<string> formatSpecifiers)
{
DkmClrType clrType = clrValue.Type;
if (clrType == null)
{
// This can be null in some error cases
return string.Empty;
}
// Try to format the value. If we can't format the value, delegate to the C# Formatter.
string value = TryFormatValue(clrValue, inspectionContext);
return value ?? clrValue.GetValueString(inspectionContext, formatSpecifiers);
}
public static string GetTypeName(this System.Type type, DkmClrCustomTypeInfo typeInfo, bool escapeKeywordIdentifiers = false, DkmInspectionContext inspectionContext = null)
{
var formatter = new CSharpFormatter();
var clrType = new DkmClrType((TypeImpl)type);
if (inspectionContext == null)
{
var inspectionSession = new DkmInspectionSession(ImmutableArray.Create<IDkmClrFormatter>(formatter), ImmutableArray.Create<IDkmClrResultProvider>(new CSharpResultProvider()));
inspectionContext = new DkmInspectionContext(inspectionSession, DkmEvaluationFlags.None, radix: 10, runtimeInstance: null);
}
return escapeKeywordIdentifiers ?
((IDkmClrFullNameProvider)formatter).GetClrTypeName(inspectionContext, clrType, typeInfo) :
inspectionContext.GetTypeName(clrType, typeInfo, Formatter.NoFormatSpecifiers);
}
public CppExpressionEvaluator(DkmThread thread, ulong frameBase, ulong vframe) {
_process = thread.Process;
var inspectionSession = DkmInspectionSession.Create(_process, null);
_cppInspectionContext = DkmInspectionContext.Create(inspectionSession, _process.GetNativeRuntimeInstance(), thread, Timeout,
DkmEvaluationFlags.TreatAsExpression | DkmEvaluationFlags.NoSideEffects, DkmFuncEvalFlags.None, 10, CppLanguage, null);
const int CV_ALLREG_VFRAME = 0x00007536;
var vframeReg = DkmUnwoundRegister.Create(CV_ALLREG_VFRAME, new ReadOnlyCollection<byte>(BitConverter.GetBytes(vframe)));
var regs = thread.GetCurrentRegisters(new[] { vframeReg });
var iaddr = _process.CreateNativeInstructionAddress(regs.GetInstructionPointer());
_nativeFrame = DkmStackWalkFrame.Create(thread, iaddr, frameBase, 0, DkmStackWalkFrameFlags.None, null, regs, null);
}
private DkmFailedEvaluationResult(
DkmInspectionContext inspectionContext,
DkmStackWalkFrame stackFrame,
string name,
string fullName,
string errorMessage,
DkmEvaluationResultFlags flags,
string type,
DkmDataItem dataItem) :
base(inspectionContext, stackFrame, name, fullName, flags, type, dataItem)
{
this.ErrorMessage = errorMessage;
}
private static DkmEvaluationResult GetRow(
ResultProvider resultProvider,
DkmInspectionContext inspectionContext,
DkmClrValue pointer,
Type elementType,
EvalResultDataItem parent)
{
var value = pointer.Dereference();
var valueType = value.Type.GetLmrType();
var wasExceptionThrown = value.EvalFlags.Includes(DkmEvaluationResultFlags.ExceptionThrown);
string debuggerDisplayName;
string debuggerDisplayValue;
string debuggerDisplayType;
value.GetDebuggerDisplayStrings(out debuggerDisplayName, out debuggerDisplayValue, out debuggerDisplayType);
var declaredType = elementType;
var typeName = debuggerDisplayType ?? pointer.InspectionContext.GetTypeName(DkmClrType.Create(pointer.Type.AppDomain, declaredType));
var expansion = wasExceptionThrown
? null
: resultProvider.GetTypeExpansion(inspectionContext, declaredType, value, ExpansionFlags.None);
var fullName = string.Format("*{0}", parent.ChildFullNamePrefix);
var editableValue = resultProvider.Formatter.GetEditableValue(value);
// NB: Full name is based on the real (i.e. not DebuggerDisplay) name. This is a change from dev12,
// which used the DebuggerDisplay name, causing surprising results in "Add Watch" scenarios.
var dataItem = new EvalResultDataItem(
name: null, // Okay for pointer dereferences.
typeDeclaringMember: null,
declaredType: declaredType,
value: value,
expansion: expansion,
childShouldParenthesize: true,
fullName: fullName,
childFullNamePrefixOpt: fullName,
formatSpecifiers: Formatter.NoFormatSpecifiers,
category: DkmEvaluationResultCategory.Other,
flags: DkmEvaluationResultFlags.None,
editableValue: editableValue);
var name = debuggerDisplayName ?? fullName;
var display = debuggerDisplayValue ??
(wasExceptionThrown ? string.Format(Resources.InvalidPointerDereference, fullName) : value.GetValueString());
return ResultProvider.CreateEvaluationResult(
value,
name,
typeName,
display,
dataItem);
}
private static string TryGetFrameNameHelper(DkmInspectionContext inspectionContext, DkmStackWalkFrame frame, DkmVariableInfoFlags argumentFlags)
{
ImportedMethod currentMethod = TryGetCurrentMethod(inspectionContext, frame);
if (currentMethod == null)
return null;
string name = currentMethod.Name;
if (string.Equals(name, "$.main", StringComparison.Ordinal))
return "<Main Block>";
if (argumentFlags == DkmVariableInfoFlags.None)
return name;
Variable[] args = currentMethod.GetParameters();
if (args.Length == 0)
return name;
StringBuilder nameBuilder = new StringBuilder();
nameBuilder.Append(name);
nameBuilder.Append('(');
bool first = true;
bool showTypes = argumentFlags.HasFlag(DkmVariableInfoFlags.Types);
bool showNames = argumentFlags.HasFlag(DkmVariableInfoFlags.Names);
foreach (Variable arg in args)
{
if (first)
first = false;
else
nameBuilder.Append("; ");
IrisType argType = arg.Type;
if (argType.IsByRef)
{
nameBuilder.Append("var ");
argType = argType.GetElementType();
}
if (showNames)
nameBuilder.Append(arg.Name);
if (showNames && showTypes)
nameBuilder.Append(" : ");
if (showTypes)
nameBuilder.Append(argType);
}
nameBuilder.Append(')');
return nameBuilder.ToString();
}
void IDkmClrResultProvider.GetResult(DkmClrValue value, DkmWorkList workList, DkmClrType declaredType, DkmClrCustomTypeInfo declaredTypeInfo, DkmInspectionContext inspectionContext, ReadOnlyCollection<string> formatSpecifiers, string resultName, string resultFullName, DkmCompletionRoutine<DkmEvaluationAsyncResult> completionRoutine)
{
// TODO: Use full name
var wl = new WorkList(workList, e => completionRoutine(DkmEvaluationAsyncResult.CreateErrorResult(e)));
GetRootResultAndContinue(
value,
wl,
declaredType,
declaredTypeInfo,
inspectionContext,
resultName,
result => wl.ContinueWith(() => completionRoutine(new DkmEvaluationAsyncResult(result))));
wl.Execute();
}
public virtual void GetChildren(DkmWorkList workList, int initialRequestSize, DkmInspectionContext inspectionContext, DkmCompletionRoutine <DkmGetChildrenAsyncResult> completionRoutine)
{
throw new NotImplementedException();
}
public static DkmEvaluationResultEnumContext Create(int Count, DkmStackWalkFrame StackFrame, DkmInspectionContext InspectionContext, DkmDataItem DataItem)
{
var enumContext = new DkmEvaluationResultEnumContext(Count, InspectionContext);
if (DataItem != null)
{
enumContext.SetDataItem(DkmDataCreationDisposition.CreateNew, DataItem);
}
return(enumContext);
}
internal DkmEvaluationResultEnumContext(int count, DkmInspectionContext inspectionContext)
{
this.Count = count;
this.InspectionContext = inspectionContext;
}
