internal DkmEvaluationResult[] GetItems(
DkmEvaluationResultEnumContext enumContext,
int startIndex,
int count
)
{
DkmEvaluationEnumAsyncResult getItemsResult = default(DkmEvaluationEnumAsyncResult);
var workList = new DkmWorkList();
enumContext.GetItems(
workList,
startIndex,
count,
r =>
{
getItemsResult = r;
}
);
workList.Execute();
var exception = getItemsResult.Exception;
if (exception != null)
{
ExceptionDispatchInfo.Capture(exception).Throw();
}
return(getItemsResult.Items);
}
public void GetChildren(DkmVisualizedExpression visualizedExpression, int initialRequestSize, DkmInspectionContext inspectionContext, out DkmChildVisualizedExpression[] initialChildren, out DkmEvaluationResultEnumContext enumContext)
{
var rawResultHolder = visualizedExpression.GetDataItem <RawEvaluationResultHolder>();
if (rawResultHolder == null)
{
Debug.Fail("PythonViewNativeVisualizer.GetChildren passed a visualized expression that does not have an associated RawEvaluationResultHolder.");
throw new NotSupportedException();
}
var rawResult = rawResultHolder.RawResult;
DkmEvaluationResult[] rawInitialChildren;
DkmEvaluationResultEnumContext rawEnumContext;
visualizedExpression.GetChildrenCallback(rawResult, 0, inspectionContext, out rawInitialChildren, out rawEnumContext);
initialChildren = new DkmChildVisualizedExpression[0];
enumContext = rawEnumContext;
if (DebuggerOptions.ShowPythonViewNodes)
{
var pythonView = GetPythonView(visualizedExpression, (uint)rawEnumContext.Count);
if (pythonView != null)
{
enumContext = DkmEvaluationResultEnumContext.Create(
rawEnumContext.Count + 1,
rawEnumContext.StackFrame,
rawEnumContext.InspectionContext,
new RawEnumContextData {
RawContext = rawEnumContext, PythonView = pythonView
});
}
}
}
public void GetItems(DkmVisualizedExpression visualizedExpression, DkmEvaluationResultEnumContext enumContext, int startIndex, int count, out DkmChildVisualizedExpression[] items)
{
DkmEvaluationResult[] itemsAsResult;
visualizedExpression.GetItemsCallback(enumContext, startIndex, count, out itemsAsResult);
items = Convert(visualizedExpression, itemsAsResult, startIndex);
}
internal DkmEvaluationResult[] GetChildren(
DkmEvaluationResult evalResult,
int initialRequestSize,
DkmInspectionContext inspectionContext,
out DkmEvaluationResultEnumContext enumContext
)
{
DkmGetChildrenAsyncResult getChildrenResult = default(DkmGetChildrenAsyncResult);
var workList = new DkmWorkList();
evalResult.GetChildren(
workList,
initialRequestSize,
inspectionContext ?? DefaultInspectionContext,
r =>
{
getChildrenResult = r;
}
);
workList.Execute();
var exception = getChildrenResult.Exception;
if (exception != null)
{
ExceptionDispatchInfo.Capture(exception).Throw();
}
enumContext = getChildrenResult.EnumContext;
return(getChildrenResult.InitialChildren);
}
private void GetChildrenAndContinue(EvalResultDataItem dataItem, DkmWorkList workList, DkmStackWalkFrame stackFrame, int initialRequestSize, DkmInspectionContext inspectionContext, DkmCompletionRoutine <DkmGetChildrenAsyncResult> completionRoutine)
{
var expansion = dataItem.Expansion;
var rows = ArrayBuilder <EvalResultDataItem> .GetInstance();
int index = 0;
if (expansion != null)
{
expansion.GetRows(this, rows, inspectionContext, dataItem, dataItem.Value, 0, initialRequestSize, visitAll: true, index: ref index);
}
var numRows = rows.Count;
Debug.Assert(index >= numRows);
Debug.Assert(initialRequestSize >= numRows);
var initialChildren = new DkmEvaluationResult[numRows];
GetEvaluationResultsAndContinue(rows, initialChildren, 0, numRows, workList, inspectionContext, stackFrame,
() => ContinueWithExceptionHandling(
() =>
{
var enumContext = DkmEvaluationResultEnumContext.Create(index, stackFrame, inspectionContext, new EnumContextDataItem(dataItem));
completionRoutine(new DkmGetChildrenAsyncResult(initialChildren, enumContext));
rows.Free();
},
e => completionRoutine(DkmGetChildrenAsyncResult.CreateErrorResult(e))));
}
public override void PrepareExpansion(out DkmEvaluationResultEnumContext enumContext)
{
// First, default expansion
// @TODO: Calling this both in EvaluateExpressionResult, and from UseDefaultEvaluationBehavior
// in the component. Be good if we can somehow test if this is actually redoing the evaluation,
// or just returning the existing one.
var eval = DefaultEE.DefaultEval(expression_, true);
DkmEvaluationResult[] children;
DkmEvaluationResultEnumContext default_enum_ctx;
expression_.GetChildrenCallback(eval, 0, expression_.InspectionContext, out children, out default_enum_ctx);
// Now any custom additions to the expansion
int custom_children = 0;
// Need to determine if we should display the property list child
DeterminePropertyListVisibility();
if (IsPropertyListShown)
{
custom_children++;
}
// Create an aggregate enumeration context, with the length of the default enum, plus what we are adding on.
// Store the default enumeration context inside it as a data item.
enumContext = DkmEvaluationResultEnumContext.Create(
default_enum_ctx.Count + custom_children,
expression_.StackFrame,
expression_.InspectionContext,
new DefaultEnumContextDataItem(default_enum_ctx)
);
}
public void GetItems(DkmVisualizedExpression visualizedExpression, DkmEvaluationResultEnumContext enumContext, int startIndex, int count, out DkmChildVisualizedExpression[] items)
{
if (count == 0)
{
items = new DkmChildVisualizedExpression[0];
return;
}
var rawContextData = enumContext.GetDataItem <RawEnumContextData>();
var rawContext = rawContextData != null ? rawContextData.RawContext : enumContext;
var result = new List <DkmChildVisualizedExpression>(count);
if (rawContextData != null && rawContextData.PythonView != null)
{
if (startIndex == 0)
{
result.Add(rawContextData.PythonView);
--count;
}
else
{
--startIndex;
}
}
DkmEvaluationResult[] rawItems;
visualizedExpression.GetItemsCallback(rawContext, startIndex, count, out rawItems);
for (int i = 0; i < rawItems.Length; ++i)
{
var rawItem = rawItems[i];
var rawSuccessItem = rawItem as DkmSuccessEvaluationResult;
DkmExpressionValueHome home = null;
if (rawSuccessItem != null && rawSuccessItem.Address != null)
{
home = DkmPointerValueHome.Create(rawSuccessItem.Address.Value);
}
else
{
home = DkmFakeValueHome.Create(0);
}
var item = DkmChildVisualizedExpression.Create(
visualizedExpression.InspectionContext,
visualizedExpression.VisualizerId,
visualizedExpression.SourceId,
visualizedExpression.StackFrame,
home,
rawItem,
visualizedExpression,
(uint)(startIndex + i),
rawItem.GetDataItem <RawEvaluationResultHolder>());
result.Add(item);
}
items = result.ToArray();
}
void IDkmCustomVisualizer.GetItems(DkmVisualizedExpression expression, DkmEvaluationResultEnumContext enumContext, int startIndex, int count, out DkmChildVisualizedExpression[] items)
{
var data_item = expression.GetDataItem <ExpressionDataItem>();
var visualizer = data_item.Visualizer;
Debug.Assert(visualizer != null);
visualizer.GetChildItems(enumContext, startIndex, count, out items);
}
void IDkmClrResultProvider.GetItems(
DkmEvaluationResultEnumContext enumContext,
DkmWorkList workList,
int startIndex,
int count,
DkmCompletionRoutine <DkmEvaluationEnumAsyncResult> completionRoutine
)
{
enumContext.GetItems(workList, startIndex, count, completionRoutine);
}
public override void PrepareExpansion(out DkmEvaluationResultEnumContext enumContext)
{
EvaluateProperties();
enumContext = DkmEvaluationResultEnumContext.Create(
GetNumProperties(),
expression_.StackFrame,
expression_.InspectionContext,
null
);
}
void IDkmCustomVisualizer.GetItems(DkmVisualizedExpression expression, DkmEvaluationResultEnumContext enumContext, int startIndex, int count, out DkmChildVisualizedExpression[] items)
{
EvaluationDataItem dataItem = expression.GetDataItem <EvaluationDataItem>();
if (dataItem == null)
{
Debug.Fail("DebugComponent.GetItems passed a visualized expression that does not have an associated ExpressionDataItem.");
throw new NotSupportedException();
}
items = dataItem.Visualizer.GetChildItems(startIndex, count);
}
void IDkmLanguageExpressionEvaluator.GetItems(DkmEvaluationResultEnumContext enumContext, DkmWorkList workList, int startIndex, int count, DkmCompletionRoutine <DkmEvaluationEnumAsyncResult> completionRoutine)
{
var ee = enumContext.StackFrame.Process.GetDataItem <ExpressionEvaluator>();
if (ee == null)
{
Debug.Fail("GetItems called, but no instance of ExpressionEvaluator exists in this DkmProcess to handle it.");
throw new InvalidOperationException();
}
ee.GetItems(enumContext, workList, startIndex, count, completionRoutine);
}
internal DkmEvaluationResult[] GetItems(DkmEvaluationResultEnumContext enumContext, int startIndex, int count)
{
DkmEvaluationEnumAsyncResult getItemsResult = default(DkmEvaluationEnumAsyncResult);
_resultProvider.GetItems(enumContext, null, startIndex, count, r => { getItemsResult = r; });
var exception = getItemsResult.Exception;
if (exception != null)
{
ExceptionDispatchInfo.Capture(exception).Throw();
}
return(getItemsResult.Items);
}
void IDkmClrResultProvider.GetItems(DkmEvaluationResultEnumContext enumContext, DkmWorkList workList, int startIndex, int count, DkmCompletionRoutine <DkmEvaluationEnumAsyncResult> completionRoutine)
{
var dataItem = enumContext.GetDataItem <EnumContextDataItem>();
if (dataItem == null)
{
// We don't know about this result. Call next implementation
enumContext.GetItems(workList, startIndex, count, completionRoutine);
return;
}
GetItemsAndContinue(dataItem.EvalResultDataItem, workList, startIndex, count, enumContext.InspectionContext, completionRoutine);
}
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;
}
var expansion = dataItem.Expansion;
if (expansion == null)
{
var enumContext = DkmEvaluationResultEnumContext.Create(0, evaluationResult.StackFrame, inspectionContext, new EnumContextDataItem(evaluationResult));
completionRoutine(new DkmGetChildrenAsyncResult(new DkmEvaluationResult[0], enumContext));
return;
}
// Evaluate children with InspectionContext that is not the root.
inspectionContext = inspectionContext.With(NotRoot);
var rows = ArrayBuilder <EvalResult> .GetInstance();
int index = 0;
expansion.GetRows(this, rows, inspectionContext, dataItem, dataItem.Value, 0, initialRequestSize, visitAll: true, index: ref index);
var numRows = rows.Count;
Debug.Assert(index >= numRows);
Debug.Assert(initialRequestSize >= numRows);
var initialChildren = new DkmEvaluationResult[numRows];
CompletionRoutine <Exception> onException = e => completionRoutine(DkmGetChildrenAsyncResult.CreateErrorResult(e));
var wl = new WorkList(workList, onException);
wl.ContinueWith(() =>
GetEvaluationResultsAndContinue(evaluationResult, rows, initialChildren, 0, numRows, wl, inspectionContext,
() =>
wl.ContinueWith(
() =>
{
var enumContext = DkmEvaluationResultEnumContext.Create(index, evaluationResult.StackFrame, inspectionContext, new EnumContextDataItem(evaluationResult));
completionRoutine(new DkmGetChildrenAsyncResult(initialChildren, enumContext));
rows.Free();
}),
onException));
}
void IDkmClrResultProvider.GetItems(DkmEvaluationResultEnumContext enumContext, DkmWorkList workList, int startIndex, int count, DkmCompletionRoutine <DkmEvaluationEnumAsyncResult> completionRoutine)
{
var enumContextDataItem = enumContext.GetDataItem <EnumContextDataItem>();
if (enumContextDataItem == null)
{
// We don't know about this result. Call next implementation
enumContext.GetItems(workList, startIndex, count, completionRoutine);
return;
}
var evaluationResult = enumContextDataItem.Result;
var dataItem = evaluationResult.GetDataItem <EvalResultDataItem>();
var expansion = dataItem.Expansion;
if (expansion == null)
{
completionRoutine(new DkmEvaluationEnumAsyncResult(new DkmEvaluationResult[0]));
return;
}
var inspectionContext = enumContext.InspectionContext;
var rows = ArrayBuilder <EvalResult> .GetInstance();
int index = 0;
expansion.GetRows(this, rows, inspectionContext, dataItem, dataItem.Value, startIndex, count, visitAll: false, index: ref index);
var numRows = rows.Count;
Debug.Assert(count >= numRows);
var results = new DkmEvaluationResult[numRows];
CompletionRoutine <Exception> onException = e => completionRoutine(DkmEvaluationEnumAsyncResult.CreateErrorResult(e));
var wl = new WorkList(workList, onException);
wl.ContinueWith(() =>
GetEvaluationResultsAndContinue(evaluationResult, rows, results, 0, numRows, wl, inspectionContext,
() =>
wl.ContinueWith(
() =>
{
completionRoutine(new DkmEvaluationEnumAsyncResult(results));
rows.Free();
}),
onException));
}
/// <summary>
/// Returns number of child elements in previous evaluation.
/// </summary>
public void GetChildren(DkmVisualizedExpression visualizedExpression, int initialRequestSize, DkmInspectionContext inspectionContext, out DkmChildVisualizedExpression[] initialChildren, out DkmEvaluationResultEnumContext enumContext)
{
// Check if we want to use passthrough visualizer
PassThroughVisualizer passThroughVisualizer = visualizedExpression.GetDataItem <PassThroughVisualizer>();
if (passThroughVisualizer != null)
{
passThroughVisualizer.GetChildren(visualizedExpression, initialRequestSize, inspectionContext, out initialChildren, out enumContext);
return;
}
// Execute our regular visualizer
VSCustomVisualizerEvaluator evaluator = visualizedExpression.GetDataItem <VSCustomVisualizerEvaluator>();
initialChildren = new DkmChildVisualizedExpression[0];
enumContext = DkmEvaluationResultEnumContext.Create(evaluator.ResultVisualizer?.Children.Count() ?? 0, visualizedExpression.StackFrame, visualizedExpression.InspectionContext, evaluator);
}
public override void GetChildItems(DkmEvaluationResultEnumContext enumContext, int start, int count, out DkmChildVisualizedExpression[] items)
{
var props = GetAllProperties();
int total_num_props = props.Length;
int end_idx = Math.Min(start + count, total_num_props);
int num_to_return = end_idx - start;
items = new DkmChildVisualizedExpression[num_to_return];
for (int idx = start, out_idx = 0; idx < end_idx; ++idx, ++out_idx)
{
// We want to construct our own visualized expression from the eval.
var eval = props[idx] as DkmSuccessEvaluationResult;
// @TODO: Perhaps allow for failed evaluations and display anyway with unknown value??
Debug.Assert(eval != null);
DkmExpressionValueHome home;
if (eval.Address != null)
{
home = DkmPointerValueHome.Create(eval.Address.Value);
}
else
{
home = DkmFakeValueHome.Create(0);
}
var expr = DkmChildVisualizedExpression.Create(
expression_.InspectionContext,
// @TODO: This is weird... seems to affect whether we get callback.
// Obviously the properties can be of any type, UObject or not.
// Perhaps best to put back the guid for PropertyValue, even though we don't really need to use it.
Guids.Visualizer.PropertyValue, //Guids.Visualizer.UObject,//Guids.Visualizer.PropertyList,
// Seems that in order for these to be passed back to the EE for default expansion, they need to be given
// the SourceId from the originally received root expression.
PropListExpression.Parent.SourceId,
expression_.StackFrame,
home,
eval,
expression_,
(uint)idx,
null // Don't associate any data with the expression. If the EE calls back to us to expand it, we'll just tell it to use default expansion.
);
items[out_idx] = expr;
}
}
void IDkmCustomVisualizer.GetChildren(DkmVisualizedExpression expression, int initialRequestSize, DkmInspectionContext inspectionContext, out DkmChildVisualizedExpression[] initialChildren, out DkmEvaluationResultEnumContext enumContext)
{
EvaluationDataItem dataItem = expression.GetDataItem <EvaluationDataItem>();
if (dataItem == null)
{
Debug.Fail("DebugComponent.GetChildren passed a visualized expression that does not have an associated ExpressionDataItem.");
throw new NotSupportedException();
}
initialChildren = new DkmChildVisualizedExpression[0];
enumContext = DkmEvaluationResultEnumContext.Create(
dataItem.Visualizer.ChildElementCount,
expression.StackFrame,
expression.InspectionContext,
null);
}
void IDkmClrResultProvider.GetItems(DkmEvaluationResultEnumContext enumContext, DkmWorkList workList, int startIndex, int count, DkmCompletionRoutine <DkmEvaluationEnumAsyncResult> completionRoutine)
{
try
{
var dataItem = enumContext.GetDataItem <EnumContextDataItem>();
if (dataItem == null)
{
// We don't know about this result. Call next implementation
enumContext.GetItems(workList, startIndex, count, completionRoutine);
return;
}
completionRoutine(GetItems(enumContext.InspectionContext, dataItem.EvalResultDataItem, startIndex, count));
}
catch (Exception e) when(ExpressionEvaluatorFatalError.CrashIfFailFastEnabled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
private DkmGetChildrenAsyncResult GetChildren(DkmInspectionContext inspectionContext, DkmEvaluationResult evaluationResult, EvalResultDataItem dataItem, int initialRequestSize)
{
var expansion = dataItem.Expansion;
var builder = ArrayBuilder <DkmEvaluationResult> .GetInstance();
int index = 0;
if (expansion != null)
{
expansion.GetRows(this, builder, inspectionContext, dataItem, dataItem.Value, 0, initialRequestSize, visitAll: true, index: ref index);
}
var rows = builder.ToArrayAndFree();
Debug.Assert(index >= rows.Length);
Debug.Assert(initialRequestSize >= rows.Length);
var enumContext = DkmEvaluationResultEnumContext.Create(index, evaluationResult.StackFrame, evaluationResult.InspectionContext, new EnumContextDataItem(dataItem));
return(new DkmGetChildrenAsyncResult(rows, enumContext));
}
public DefaultEnumContextDataItem(DkmEvaluationResultEnumContext ctx)
{
default_enum_ctx_ = ctx;
}
/// <summary>
/// Returns child elements of previous evaluation.
/// </summary>
public void GetItems(DkmVisualizedExpression visualizedExpression, DkmEvaluationResultEnumContext enumContext, int startIndex, int count, out DkmChildVisualizedExpression[] items)
{
// Check if we want to use passthrough visualizer
PassThroughVisualizer passThroughVisualizer = enumContext.GetDataItem <PassThroughVisualizer>();
if (passThroughVisualizer != null)
{
passThroughVisualizer.GetItems(visualizedExpression, enumContext, startIndex, count, out items);
return;
}
// Execute our regular visualizer
VSCustomVisualizerEvaluator evaluator = visualizedExpression.GetDataItem <VSCustomVisualizerEvaluator>();
IResultVisualizer[] itemsAsResults = evaluator.ResultVisualizer.Children.Skip(startIndex).Take(count).ToArray();
items = new DkmChildVisualizedExpression[itemsAsResults.Length];
for (int i = 0; i < items.Length; i++)
{
IResultVisualizer item = itemsAsResults[i];
DkmEvaluationResultCategory category;
switch (item.DataType)
{
case CompletionDataType.Class:
category = DkmEvaluationResultCategory.Class;
break;
case CompletionDataType.Property:
case CompletionDataType.StaticProperty:
category = DkmEvaluationResultCategory.Property;
break;
case CompletionDataType.Event:
category = DkmEvaluationResultCategory.Event;
break;
case CompletionDataType.Method:
category = DkmEvaluationResultCategory.Method;
break;
case CompletionDataType.Enum:
case CompletionDataType.EnumValue:
case CompletionDataType.Keyword:
case CompletionDataType.Namespace:
case CompletionDataType.StaticClass:
case CompletionDataType.StaticEvent:
case CompletionDataType.StaticMethod:
case CompletionDataType.StaticVariable:
case CompletionDataType.Unknown:
case CompletionDataType.Variable:
default:
category = DkmEvaluationResultCategory.Data;
break;
}
DkmExpressionValueHome valueHome = visualizedExpression.ValueHome;
ulong address = 0;
string fullName = string.Empty;
string typeName = null;
try
{
if (item.Value is Variable variable)
{
address = variable.GetPointerAddress();
typeName = variable.GetCodeType().Name;
fullName = $"*(({typeName}*)0x{address:X})";
valueHome = DkmPointerValueHome.Create(address);
}
}
catch
{
}
DkmEvaluationResult result;
DkmDataItem dataItem = null;
if (item.ShouldForceDefaultVisualizer && !string.IsNullOrEmpty(fullName))
{
using (DkmLanguageExpression languageExpression = DkmLanguageExpression.Create(visualizedExpression.InspectionContext.Language, DkmEvaluationFlags.TreatAsExpression, fullName, null))
{
visualizedExpression.EvaluateExpressionCallback(visualizedExpression.InspectionContext, languageExpression, visualizedExpression.StackFrame, out result);
}
if (result is DkmSuccessEvaluationResult successResult)
{
dataItem = new PassThroughVisualizer(successResult);
result = DkmSuccessEvaluationResult.Create(
successResult.InspectionContext,
successResult.StackFrame,
item.Name, // Name - Left column
successResult.FullName,
successResult.Flags,
successResult.Value, // Value - Middle column
successResult.EditableValue,
successResult.Type, // Type - Right column
category,
successResult.Access,
successResult.StorageType,
successResult.TypeModifierFlags,
successResult.Address,
successResult.CustomUIVisualizers,
successResult.ExternalModules,
successResult.RefreshButtonText,
dataItem);
}
}
else
{
result = DkmSuccessEvaluationResult.Create(
visualizedExpression.InspectionContext,
visualizedExpression.StackFrame,
item.Name, // Name - Left column
fullName, // FullName - What is being copied when "Add to watch"
DkmEvaluationResultFlags.ReadOnly | (item.IsExpandable ? DkmEvaluationResultFlags.Expandable : DkmEvaluationResultFlags.None),
item.ValueString, // Value - Middle column
"",
item.Type ?? "", // Type - Right column
category,
DkmEvaluationResultAccessType.None,
DkmEvaluationResultStorageType.None,
DkmEvaluationResultTypeModifierFlags.None,
null,
VSUIVisualizerService.GetUIVisualizers(item),
null,
null);
dataItem = new VSCustomVisualizerEvaluator(result, item);
}
items[i] = DkmChildVisualizedExpression.Create(
visualizedExpression.InspectionContext,
visualizedExpression.VisualizerId,
visualizedExpression.SourceId,
visualizedExpression.StackFrame,
valueHome,
result,
visualizedExpression,
(uint)(startIndex + i),
dataItem);
}
}
public void GetChildren(DkmVisualizedExpression visualizedExpression, int initialRequestSize, DkmInspectionContext inspectionContext, out DkmChildVisualizedExpression[] initialChildren, out DkmEvaluationResultEnumContext enumContext)
{
DkmEvaluationResult[] initialChildrenAsResult;
visualizedExpression.GetChildrenCallback(EvaluationResult, 0, inspectionContext, out initialChildrenAsResult, out enumContext);
initialChildren = Convert(visualizedExpression, initialChildrenAsResult);
enumContext.SetDataItem(DkmDataCreationDisposition.CreateAlways, this);
}
public void GetItems(DkmVisualizedExpression visualizedExpression, DkmEvaluationResultEnumContext enumContext, int startIndex, int count, out DkmChildVisualizedExpression[] items)
{
throw new NotImplementedException();
}
void IDkmCustomVisualizer.GetChildren(DkmVisualizedExpression visualizedExpression, int initialRequestSize, DkmInspectionContext inspectionContext, out DkmChildVisualizedExpression[] initialChildren, out DkmEvaluationResultEnumContext enumContext)
{
var natVis = visualizedExpression.StackFrame.Process.GetOrCreateDataItem(() => new PyObjectNativeVisualizer());
natVis.GetChildren(visualizedExpression, initialRequestSize, inspectionContext, out initialChildren, out enumContext);
}
void IDkmCustomVisualizer.GetChildren(DkmVisualizedExpression expression, int initialRequestSize, DkmInspectionContext inspectionContext, out DkmChildVisualizedExpression[] initialChildren, out DkmEvaluationResultEnumContext enumContext)
{
Debug.Print("UE4PV: GetChildren('{0}'/'{1}', [{2}, {3}])",
Utility.GetExpressionFullName(expression),
Utility.GetExpressionName(expression),
expression.TagValue,
expression.VisualizerId
);
var data_item = expression.GetDataItem <ExpressionDataItem>();
var visualizer = data_item.Visualizer;
Debug.Assert(visualizer != null);
visualizer.PrepareExpansion(out enumContext);
initialChildren = new DkmChildVisualizedExpression[0];
}
public DefaultChildEvaluator(DkmVisualizedExpression expression, ChildDisplayMode mode)
{
this.mode_ = mode;
this.expression_ = expression;
this.defEnumContext_ = null;
}
void IDkmCustomVisualizer.GetItems(DkmVisualizedExpression visualizedExpression, DkmEvaluationResultEnumContext enumContext, int startIndex, int count, out DkmChildVisualizedExpression[] items)
{
var natVis = visualizedExpression.StackFrame.Process.GetOrCreateDataItem(() => new PyObjectNativeVisualizer());
natVis.GetItems(visualizedExpression, enumContext, startIndex, count, out items);
}
public void GetChildren(DkmVisualizedExpression visualizedExpression, int initialRequestSize, DkmInspectionContext inspectionContext, out DkmChildVisualizedExpression[] initialChildren, out DkmEvaluationResultEnumContext enumContext)
{
throw new NotImplementedException();
}
